home *** CD-ROM | disk | FTP | other *** search
/ The Utilities Experience / The Utilities Experience - Volume 1.iso / software / misc / o-z / x-windows / mesa-amiwin / src / get.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-30  |  83.0 KB  |  2,867 lines
  1. /* get.c */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  1.2
  6.  * Copyright (C) 1995  Brian Paul  (brianp@ssec.wisc.edu)
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25. $Id: get.c,v 1.17 1995/10/27 20:29:02 brianp Exp $
  26.  
  27. $Log: get.c,v $
  28.  * Revision 1.17  1995/10/27  20:29:02  brianp
  29.  * added glPolygonOffsetEXT() support
  30.  *
  31.  * Revision 1.16  1995/10/14  16:29:18  brianp
  32.  * replaced dd_buffer_info with DD.buffer_size
  33.  *
  34.  * Revision 1.15  1995/08/31  21:29:33  brianp
  35.  * new TexGenEnabled bitfield
  36.  *
  37.  * Revision 1.14  1995/07/12  21:19:02  brianp
  38.  * bug fix:  glGet(GL_DEPTH_BITS) returned bytes, not bits (per Tor Stenvaag)
  39.  *
  40.  * Revision 1.13  1995/06/08  20:51:57  brianp
  41.  * added missing RenderMode to glGetDoublev()
  42.  *
  43.  * Revision 1.12  1995/05/22  21:02:41  brianp
  44.  * Release 1.2
  45.  *
  46.  * Revision 1.11  1995/05/17  13:52:37  brianp
  47.  * implemented glIndexMask(0) and glColorMask(0,0,0,0)
  48.  *
  49.  * Revision 1.10  1995/05/15  15:24:07  brianp
  50.  * replaced CC.CurrentListNum with gl_list_index()
  51.  *
  52.  * Revision 1.9  1995/05/12  19:26:43  brianp
  53.  * replaced CC.Mode!=0 with INSIDE_BEGIN_END
  54.  *
  55.  * Revision 1.8  1995/05/12  17:00:43  brianp
  56.  * changed CC.Mode!=0 to INSIDE_BEGIN_END
  57.  *
  58.  * Revision 1.7  1995/03/27  20:31:53  brianp
  59.  * new Texture.Enabled scheme
  60.  *
  61.  * Revision 1.6  1995/03/24  15:28:47  brianp
  62.  * replaced ACCUM_BITS with ACC_TYPE
  63.  *
  64.  * Revision 1.5  1995/03/22  21:37:22  brianp
  65.  * removed BufferDepth from CC
  66.  *
  67.  * Revision 1.4  1995/03/10  16:25:53  brianp
  68.  * updated for blending extensions
  69.  *
  70.  * Revision 1.3  1995/03/10  14:26:58  brianp
  71.  * implemented get(GL_CURRENT_RASTER_TEXTURE_COORDS)
  72.  *
  73.  * Revision 1.2  1995/03/04  19:29:44  brianp
  74.  * 1.1 beta revision
  75.  *
  76.  * Revision 1.1  1995/02/24  14:23:16  brianp
  77.  * Initial revision
  78.  *
  79.  */
  80.  
  81.  
  82. /* glGet functions */
  83.  
  84.  
  85. #include <string.h>
  86. #include "context.h"
  87. #include "dd.h"
  88. #include "list.h"
  89. #include "macros.h"
  90.  
  91.  
  92. #define FLOAT_TO_BOOL(X)    ( (X)==0.0F ? GL_FALSE : GL_TRUE )
  93. #define INT_TO_BOOL(I)        ( (I)==0 ? GL_FALSE : GL_TRUE )
  94. #define ENUM_TO_BOOL(E)        ( (E)==0 ? GL_FALSE : GL_TRUE )
  95. /*#define FLOAT_TO_INT(I)        ((GLint) (I * 2147483647.0))*/
  96.  
  97.  
  98.  
  99. /*
  100.  * Given a color component scale value such as CC.RedScale, CC.BlueScale,
  101.  * etc. return the number of bits implied by that scaling.  This is
  102.  * usually expressed by:  scale = 2^bits - 1.
  103.  * Example:  if RedScale==63.0, bits must be 6.
  104.  * Input:  a color component scale value
  105.  * Return:  number of bits implied by the scale value.
  106.  */
  107. static GLuint bits( GLfloat scale )
  108. {
  109.    GLuint iscale, bits;
  110.  
  111.    iscale = (GLuint) scale;
  112.    for (bits=0; iscale>0; bits++) {
  113.       iscale = iscale >> 1;
  114.    }
  115.    return bits;
  116. }
  117.  
  118.  
  119.  
  120. void glGetBooleanv( GLenum pname, GLboolean *params )
  121. {
  122.    GLuint i;
  123.  
  124.    if (INSIDE_BEGIN_END) {
  125.       gl_error( GL_INVALID_OPERATION, "glGetBooleanv" );
  126.       return;
  127.    }
  128.  
  129.    switch (pname) {
  130.       case GL_ACCUM_RED_BITS:
  131.       case GL_ACCUM_GREEN_BITS:
  132.       case GL_ACCUM_BLUE_BITS:
  133.       case GL_ACCUM_ALPHA_BITS:
  134.          *params = INT_TO_BOOL(sizeof(ACC_TYPE)*8);
  135.          break;
  136.       case GL_ACCUM_CLEAR_VALUE:
  137.          params[0] = FLOAT_TO_BOOL(CC.Accum.ClearColor[0]);
  138.          params[1] = FLOAT_TO_BOOL(CC.Accum.ClearColor[1]);
  139.          params[2] = FLOAT_TO_BOOL(CC.Accum.ClearColor[2]);
  140.          params[3] = FLOAT_TO_BOOL(CC.Accum.ClearColor[3]);
  141.          break;
  142.       case GL_ALPHA_BIAS:
  143.          *params = FLOAT_TO_BOOL(CC.Pixel.AlphaBias);
  144.          break;
  145.       case GL_ALPHA_BITS:
  146.          *params = INT_TO_BOOL( bits(CC.AlphaScale) );
  147.          break;
  148.       case GL_ALPHA_SCALE:
  149.          *params = FLOAT_TO_BOOL(CC.Pixel.AlphaScale);
  150.          break;
  151.       case GL_ALPHA_TEST:
  152.          *params = CC.Color.AlphaEnabled;
  153.          break;
  154.       case GL_ALPHA_TEST_FUNC:
  155.          *params = ENUM_TO_BOOL(CC.Color.AlphaFunc);
  156.          break;
  157.       case GL_ALPHA_TEST_REF:
  158.          *params = FLOAT_TO_BOOL(CC.Color.AlphaRef);
  159.          break;
  160.       case GL_ATTRIB_STACK_DEPTH:
  161.          *params = INT_TO_BOOL(CC.AttribStackDepth);
  162.          break;
  163.       case GL_AUTO_NORMAL:
  164.          *params = CC.Eval.AutoNormal;
  165.          break;
  166.       case GL_AUX_BUFFERS:
  167.          *params = (NUM_AUX_BUFFERS) ? GL_TRUE : GL_FALSE;
  168.          break;
  169.       case GL_BLEND:
  170.          *params = CC.Color.BlendEnabled;
  171.          break;
  172.       case GL_BLEND_DST:
  173.          *params = ENUM_TO_BOOL(CC.Color.BlendDst);
  174.          break;
  175.       case GL_BLEND_SRC:
  176.          *params = ENUM_TO_BOOL(CC.Color.BlendSrc);
  177.          break;
  178.       case GL_BLEND_EQUATION_EXT:
  179.      *params = ENUM_TO_BOOL( CC.Color.BlendEquation );
  180.      break;
  181.       case GL_BLEND_COLOR_EXT:
  182.      params[0] = FLOAT_TO_BOOL( CC.Color.BlendColor[0] );
  183.      params[1] = FLOAT_TO_BOOL( CC.Color.BlendColor[1] );
  184.      params[2] = FLOAT_TO_BOOL( CC.Color.BlendColor[2] );
  185.      params[3] = FLOAT_TO_BOOL( CC.Color.BlendColor[3] );
  186.      break;
  187.       case GL_BLUE_BIAS:
  188.          *params = FLOAT_TO_BOOL(CC.Pixel.BlueBias);
  189.          break;
  190.       case GL_BLUE_BITS:
  191.          *params = INT_TO_BOOL( bits( CC.BlueScale ) );
  192.          break;
  193.       case GL_BLUE_SCALE:
  194.          *params = FLOAT_TO_BOOL(CC.Pixel.BlueScale);
  195.          break;
  196.       case GL_CLIP_PLANE0:
  197.       case GL_CLIP_PLANE1:
  198.       case GL_CLIP_PLANE2:
  199.       case GL_CLIP_PLANE3:
  200.       case GL_CLIP_PLANE4:
  201.       case GL_CLIP_PLANE5:
  202.          *params = CC.Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  203.          break;
  204.       case GL_COLOR_CLEAR_VALUE:
  205.          params[0] = FLOAT_TO_BOOL(CC.Color.ClearColor[0]);
  206.          params[1] = FLOAT_TO_BOOL(CC.Color.ClearColor[1]);
  207.          params[2] = FLOAT_TO_BOOL(CC.Color.ClearColor[2]);
  208.          params[3] = FLOAT_TO_BOOL(CC.Color.ClearColor[3]);
  209.          break;
  210.       case GL_COLOR_MATERIAL:
  211.          *params = CC.Light.ColorMaterialEnabled;
  212.          break;
  213.       case GL_COLOR_MATERIAL_FACE:
  214.          *params = ENUM_TO_BOOL(CC.Light.ColorMaterialFace);
  215.          break;
  216.       case GL_COLOR_MATERIAL_PARAMETER:
  217.          *params = ENUM_TO_BOOL(CC.Light.ColorMaterialMode);
  218.          break;
  219.       case GL_COLOR_WRITEMASK:
  220.          params[0] = (CC.Color.ColorMask & 8) ? GL_TRUE : GL_FALSE;
  221.          params[1] = (CC.Color.ColorMask & 4) ? GL_TRUE : GL_FALSE;
  222.          params[2] = (CC.Color.ColorMask & 2) ? GL_TRUE : GL_FALSE;
  223.          params[3] = (CC.Color.ColorMask & 1) ? GL_TRUE : GL_FALSE;
  224.          break;
  225.       case GL_CULL_FACE:
  226.          *params = CC.Polygon.CullFlag;
  227.          break;
  228.       case GL_CULL_FACE_MODE:
  229.          *params = ENUM_TO_BOOL(CC.Polygon.CullFaceMode);
  230.          break;
  231.       case GL_CURRENT_COLOR:
  232.          params[0] = FLOAT_TO_BOOL(CC.Current.Color[0]);
  233.          params[1] = FLOAT_TO_BOOL(CC.Current.Color[1]);
  234.          params[2] = FLOAT_TO_BOOL(CC.Current.Color[2]);
  235.          params[3] = FLOAT_TO_BOOL(CC.Current.Color[3]);
  236.          break;
  237.       case GL_CURRENT_INDEX:
  238.          *params = INT_TO_BOOL(CC.Current.Index);
  239.          break;
  240.       case GL_CURRENT_NORMAL:
  241.          params[0] = FLOAT_TO_BOOL(CC.Current.Normal[0]);
  242.          params[1] = FLOAT_TO_BOOL(CC.Current.Normal[1]);
  243.          params[2] = FLOAT_TO_BOOL(CC.Current.Normal[2]);
  244.          break;
  245.       case GL_CURRENT_RASTER_COLOR:
  246.      params[0] = FLOAT_TO_BOOL(CC.Current.RasterColor[0]);
  247.      params[1] = FLOAT_TO_BOOL(CC.Current.RasterColor[1]);
  248.      params[2] = FLOAT_TO_BOOL(CC.Current.RasterColor[2]);
  249.      params[3] = FLOAT_TO_BOOL(CC.Current.RasterColor[3]);
  250.      break;
  251.       case GL_CURRENT_RASTER_DISTANCE:
  252.      *params = FLOAT_TO_BOOL(CC.Current.RasterDistance);
  253.      break;
  254.       case GL_CURRENT_RASTER_INDEX:
  255.      *params = FLOAT_TO_BOOL(CC.Current.RasterIndex);
  256.      break;
  257.       case GL_CURRENT_RASTER_POSITION:
  258.      params[0] = FLOAT_TO_BOOL(CC.Current.RasterPos[0]);
  259.      params[1] = FLOAT_TO_BOOL(CC.Current.RasterPos[1]);
  260.      params[2] = FLOAT_TO_BOOL(CC.Current.RasterPos[2]);
  261.      params[3] = FLOAT_TO_BOOL(CC.Current.RasterPos[3]);
  262.      break;
  263.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  264.          params[0] = FLOAT_TO_BOOL(CC.Current.RasterTexCoord[0]);
  265.          params[1] = FLOAT_TO_BOOL(CC.Current.RasterTexCoord[1]);
  266.          params[2] = FLOAT_TO_BOOL(CC.Current.RasterTexCoord[2]);
  267.          params[3] = FLOAT_TO_BOOL(CC.Current.RasterTexCoord[3]);
  268.      break;
  269.       case GL_CURRENT_RASTER_POSITION_VALID:
  270.          *params = CC.Current.RasterPosValid;
  271.      break;
  272.       case GL_CURRENT_TEXTURE_COORDS:
  273.          params[0] = FLOAT_TO_BOOL(CC.Current.TexCoord[0]);
  274.          params[1] = FLOAT_TO_BOOL(CC.Current.TexCoord[1]);
  275.          params[2] = FLOAT_TO_BOOL(CC.Current.TexCoord[2]);
  276.          params[3] = FLOAT_TO_BOOL(CC.Current.TexCoord[3]);
  277.      break;
  278.       case GL_DEPTH_BIAS:
  279.          *params = FLOAT_TO_BOOL(CC.Pixel.DepthBias);
  280.      break;
  281.       case GL_DEPTH_BITS:
  282.      *params = INT_TO_BOOL(8*sizeof(GLint));
  283.      break;
  284.       case GL_DEPTH_CLEAR_VALUE:
  285.          *params = FLOAT_TO_BOOL(CC.Depth.Clear);
  286.      break;
  287.       case GL_DEPTH_FUNC:
  288.          *params = ENUM_TO_BOOL(CC.Depth.Func);
  289.      break;
  290.       case GL_DEPTH_RANGE:
  291.          params[0] = FLOAT_TO_BOOL(CC.Viewport.Near);
  292.          params[1] = FLOAT_TO_BOOL(CC.Viewport.Far);
  293.      break;
  294.       case GL_DEPTH_SCALE:
  295.          *params = FLOAT_TO_BOOL(CC.Pixel.DepthScale);
  296.      break;
  297.       case GL_DEPTH_TEST:
  298.          *params = CC.Depth.Test;
  299.      break;
  300.       case GL_DEPTH_WRITEMASK:
  301.      *params = CC.Depth.Mask;
  302.      break;
  303.       case GL_DITHER:
  304.      *params = CC.Color.DitherFlag;
  305.      break;
  306.       case GL_DOUBLEBUFFER:
  307.      *params = CC.DBflag;
  308.      break;
  309.       case GL_DRAW_BUFFER:
  310.      *params = ENUM_TO_BOOL(CC.Color.DrawBuffer);
  311.      break;
  312.       case GL_EDGE_FLAG:
  313.      *params = CC.Current.EdgeFlag;
  314.      break;
  315.       case GL_FOG:
  316.      *params = CC.Fog.Enabled;
  317.      break;
  318.       case GL_FOG_COLOR:
  319.          params[0] = FLOAT_TO_BOOL(CC.Fog.Color[0]);
  320.          params[1] = FLOAT_TO_BOOL(CC.Fog.Color[1]);
  321.          params[2] = FLOAT_TO_BOOL(CC.Fog.Color[2]);
  322.          params[3] = FLOAT_TO_BOOL(CC.Fog.Color[3]);
  323.      break;
  324.       case GL_FOG_DENSITY:
  325.          *params = FLOAT_TO_BOOL(CC.Fog.Density);
  326.      break;
  327.       case GL_FOG_END:
  328.          *params = FLOAT_TO_BOOL(CC.Fog.End);
  329.      break;
  330.       case GL_FOG_HINT:
  331.      *params = ENUM_TO_BOOL(CC.Hint.Fog);
  332.      break;
  333.       case GL_FOG_INDEX:
  334.      *params = FLOAT_TO_BOOL(CC.Fog.Index);
  335.      break;
  336.       case GL_FOG_MODE:
  337.      *params = ENUM_TO_BOOL(CC.Fog.Mode);
  338.      break;
  339.       case GL_FOG_START:
  340.          *params = FLOAT_TO_BOOL(CC.Fog.End);
  341.      break;
  342.       case GL_FRONT_FACE:
  343.      *params = ENUM_TO_BOOL(CC.Polygon.FrontFace);
  344.      break;
  345.       case GL_GREEN_BIAS:
  346.          *params = FLOAT_TO_BOOL(CC.Pixel.GreenBias);
  347.      break;
  348.       case GL_GREEN_BITS:
  349.          *params = INT_TO_BOOL( bits( CC.GreenScale ) );
  350.      break;
  351.       case GL_GREEN_SCALE:
  352.          *params = FLOAT_TO_BOOL(CC.Pixel.GreenScale);
  353.      break;
  354.       case GL_INDEX_BITS:
  355.      {
  356.         GLuint width, height, depth;
  357.         (*DD.buffer_size)( &width, &height, &depth );
  358.         *params = INT_TO_BOOL(depth);
  359.      }
  360.      break;
  361.       case GL_INDEX_CLEAR_VALUE:
  362.      *params = INT_TO_BOOL(CC.Color.ClearIndex);
  363.      break;
  364.       case GL_INDEX_MODE:
  365.      *params = CC.RGBAflag ? GL_FALSE : GL_TRUE;
  366.      break;
  367.       case GL_INDEX_OFFSET:
  368.      *params = INT_TO_BOOL(CC.Pixel.IndexOffset);
  369.      break;
  370.       case GL_INDEX_SHIFT:
  371.      *params = INT_TO_BOOL(CC.Pixel.IndexShift);
  372.      break;
  373.       case GL_INDEX_WRITEMASK:
  374.      *params = INT_TO_BOOL(CC.Color.IndexMask);
  375.      break;
  376.       case GL_LIGHT0:
  377.       case GL_LIGHT1:
  378.       case GL_LIGHT2:
  379.       case GL_LIGHT3:
  380.       case GL_LIGHT4:
  381.       case GL_LIGHT5:
  382.       case GL_LIGHT6:
  383.       case GL_LIGHT7:
  384.      *params = CC.Light.Light[pname-GL_LIGHT0].Enabled;
  385.      break;
  386.       case GL_LIGHTING:
  387.      *params = CC.Light.Enabled;
  388.      break;
  389.       case GL_LIGHT_MODEL_AMBIENT:
  390.      params[0] = FLOAT_TO_BOOL(CC.Light.Model.Ambient[0]);
  391.      params[1] = FLOAT_TO_BOOL(CC.Light.Model.Ambient[1]);
  392.      params[2] = FLOAT_TO_BOOL(CC.Light.Model.Ambient[2]);
  393.      params[3] = FLOAT_TO_BOOL(CC.Light.Model.Ambient[3]);
  394.      break;
  395.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  396.      *params = CC.Light.Model.LocalViewer;
  397.      break;
  398.       case GL_LIGHT_MODEL_TWO_SIDE:
  399.      *params = CC.Light.Model.TwoSide;
  400.      break;
  401.       case GL_LINE_SMOOTH:
  402.      *params = CC.Line.SmoothFlag;
  403.      break;
  404.       case GL_LINE_SMOOTH_HINT:
  405.      *params = ENUM_TO_BOOL(CC.Hint.LineSmooth);
  406.      break;
  407.       case GL_LINE_STIPPLE:
  408.      *params = CC.Line.StippleFlag;
  409.      break;
  410.       case GL_LINE_STIPPLE_PATTERN:
  411.      *params = INT_TO_BOOL(CC.Line.StipplePattern);
  412.      break;
  413.       case GL_LINE_STIPPLE_REPEAT:
  414.      *params = INT_TO_BOOL(CC.Line.StippleFactor);
  415.      break;
  416.       case GL_LINE_WIDTH:
  417.      *params = FLOAT_TO_BOOL(CC.Line.Width);
  418.      break;
  419.       case GL_LINE_WIDTH_GRANULARITY:
  420.      *params = FLOAT_TO_BOOL(LINE_WIDTH_GRANULARITY);
  421.      break;
  422.       case GL_LINE_WIDTH_RANGE:
  423.      params[0] = FLOAT_TO_BOOL(MIN_LINE_WIDTH);
  424.      params[1] = FLOAT_TO_BOOL(MAX_LINE_WIDTH);
  425.      break;
  426.       case GL_LIST_BASE:
  427.      *params = INT_TO_BOOL(CC.List.ListBase);
  428.      break;
  429.       case GL_LIST_INDEX:
  430.      *params = INT_TO_BOOL( gl_list_index() );
  431.      break;
  432.       case GL_LIST_MODE:
  433.      *params = ENUM_TO_BOOL( CC.ExecuteFlag
  434.                   ? GL_COMPILE_AND_EXECUTE : GL_COMPILE );
  435.      break;
  436.       case GL_LOGIC_OP:
  437.      *params = CC.Color.LogicOpEnabled;
  438.      break;
  439.       case GL_LOGIC_OP_MODE:
  440.      *params = ENUM_TO_BOOL(CC.Color.LogicOp);
  441.      break;
  442.       case GL_MAP1_COLOR_4:
  443.      *params = CC.Eval.Map1Color4;
  444.      break;
  445.       case GL_MAP1_GRID_DOMAIN:
  446.      params[0] = FLOAT_TO_BOOL(CC.Eval.MapGrid1u1);
  447.      params[1] = FLOAT_TO_BOOL(CC.Eval.MapGrid1u2);
  448.      break;
  449.       case GL_MAP1_GRID_SEGMENTS:
  450.      *params = INT_TO_BOOL(CC.Eval.MapGrid1un);
  451.      break;
  452.       case GL_MAP1_INDEX:
  453.      *params = CC.Eval.Map1Index;
  454.      break;
  455.       case GL_MAP1_NORMAL:
  456.      *params = CC.Eval.Map1Normal;
  457.      break;
  458.       case GL_MAP1_TEXTURE_COORD_1:
  459.      *params = CC.Eval.Map1TextureCoord1;
  460.      break;
  461.       case GL_MAP1_TEXTURE_COORD_2:
  462.      *params = CC.Eval.Map1TextureCoord2;
  463.      break;
  464.       case GL_MAP1_TEXTURE_COORD_3:
  465.      *params = CC.Eval.Map1TextureCoord3;
  466.      break;
  467.       case GL_MAP1_TEXTURE_COORD_4:
  468.      *params = CC.Eval.Map1TextureCoord4;
  469.      break;
  470.       case GL_MAP1_VERTEX_3:
  471.      *params = CC.Eval.Map1Vertex3;
  472.      break;
  473.       case GL_MAP1_VERTEX_4:
  474.      *params = CC.Eval.Map1Vertex4;
  475.      break;
  476.       case GL_MAP2_COLOR_4:
  477.      *params = CC.Eval.Map2Color4;
  478.      break;
  479.       case GL_MAP2_GRID_DOMAIN:
  480.      params[0] = FLOAT_TO_BOOL(CC.Eval.MapGrid2u1);
  481.      params[1] = FLOAT_TO_BOOL(CC.Eval.MapGrid2u2);
  482.      params[2] = FLOAT_TO_BOOL(CC.Eval.MapGrid2v1);
  483.      params[3] = FLOAT_TO_BOOL(CC.Eval.MapGrid2v2);
  484.      break;
  485.       case GL_MAP2_GRID_SEGMENTS:
  486.      params[0] = INT_TO_BOOL(CC.Eval.MapGrid2un);
  487.      params[1] = INT_TO_BOOL(CC.Eval.MapGrid2vn);
  488.      break;
  489.       case GL_MAP2_INDEX:
  490.      *params = CC.Eval.Map2Index;
  491.      break;
  492.       case GL_MAP2_NORMAL:
  493.      *params = CC.Eval.Map2Normal;
  494.      break;
  495.       case GL_MAP2_TEXTURE_COORD_1:
  496.      *params = CC.Eval.Map2TextureCoord1;
  497.      break;
  498.       case GL_MAP2_TEXTURE_COORD_2:
  499.      *params = CC.Eval.Map2TextureCoord2;
  500.      break;
  501.       case GL_MAP2_TEXTURE_COORD_3:
  502.      *params = CC.Eval.Map2TextureCoord3;
  503.      break;
  504.       case GL_MAP2_TEXTURE_COORD_4:
  505.      *params = CC.Eval.Map2TextureCoord4;
  506.      break;
  507.       case GL_MAP2_VERTEX_3:
  508.      *params = CC.Eval.Map2Vertex3;
  509.      break;
  510.       case GL_MAP2_VERTEX_4:
  511.      *params = CC.Eval.Map2Vertex4;
  512.      break;
  513.       case GL_MAP_COLOR:
  514.      *params = CC.Pixel.MapColorFlag;
  515.      break;
  516.       case GL_MAP_STENCIL:
  517.      *params = CC.Pixel.MapStencilFlag;
  518.      break;
  519.       case GL_MATRIX_MODE:
  520.      *params = ENUM_TO_BOOL( CC.Transform.MatrixMode );
  521.      break;
  522.       case GL_MAX_ATTRIB_STACK_DEPTH:
  523.      *params = INT_TO_BOOL(MAX_ATTRIB_STACK_DEPTH);
  524.      break;
  525.       case GL_MAX_CLIP_PLANES:
  526.      *params = INT_TO_BOOL(MAX_CLIP_PLANES);
  527.      break;
  528.       case GL_MAX_EVAL_ORDER:
  529.      *params = INT_TO_BOOL(MAX_EVAL_ORDER);
  530.      break;
  531.       case GL_MAX_LIGHTS:
  532.      *params = INT_TO_BOOL(MAX_LIGHTS);
  533.      break;
  534.       case GL_MAX_LIST_NESTING:
  535.      *params = INT_TO_BOOL(MAX_LIST_NESTING);
  536.      break;
  537.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  538.      *params = INT_TO_BOOL(MAX_MODELVIEW_STACK_DEPTH);
  539.      break;
  540.       case GL_MAX_NAME_STACK_DEPTH:
  541.      *params = INT_TO_BOOL(MAX_NAME_STACK_DEPTH);
  542.      break;
  543.       case GL_MAX_PIXEL_MAP_TABLE:
  544.      *params = INT_TO_BOOL(MAX_PIXEL_MAP_TABLE);
  545.      break;
  546.       case GL_MAX_PROJECTION_STACK_DEPTH:
  547.      *params = INT_TO_BOOL(MAX_PROJECTION_STACK_DEPTH);
  548.      break;
  549.       case GL_MAX_TEXTURE_SIZE:
  550.      *params = INT_TO_BOOL(MAX_TEXTURE_SIZE);
  551.      break;
  552.       case GL_MAX_TEXTURE_STACK_DEPTH:
  553.      *params = INT_TO_BOOL(MAX_TEXTURE_STACK_DEPTH);
  554.      break;
  555.       case GL_MAX_VIEWPORT_DIMS:
  556.      params[0] = INT_TO_BOOL(MAX_WIDTH);
  557.      params[1] = INT_TO_BOOL(MAX_HEIGHT);
  558.      break;
  559.       case GL_MODELVIEW_MATRIX:
  560.      for (i=0;i<16;i++) {
  561.         params[i] = FLOAT_TO_BOOL(CC.ModelViewMatrix[i]);
  562.      }
  563.      break;
  564.       case GL_MODELVIEW_STACK_DEPTH:
  565.      *params = INT_TO_BOOL(CC.ModelViewStackDepth);
  566.      break;
  567.       case GL_NAME_STACK_DEPTH:
  568.      *params = INT_TO_BOOL(CC.NameStackDepth);
  569.      break;
  570.       case GL_NORMALIZE:
  571.      *params = CC.Transform.Normalize;
  572.      break;
  573.       case GL_PACK_ALIGNMENT:
  574.      *params = INT_TO_BOOL(CC.PackAlignment);
  575.      break;
  576.       case GL_PACK_LSB_FIRST:
  577.      *params = CC.PackLSBFirst;
  578.      break;
  579.       case GL_PACK_ROW_LENGTH:
  580.      *params = INT_TO_BOOL(CC.PackRowLength);
  581.      break;
  582.       case GL_PACK_SKIP_PIXELS:
  583.      *params = INT_TO_BOOL(CC.PackSkipPixels);
  584.      break;
  585.       case GL_PACK_SKIP_ROWS:
  586.      *params = INT_TO_BOOL(CC.PackSkipRows);
  587.      break;
  588.       case GL_PACK_SWAP_BYTES:
  589.      *params = CC.PackSwapBytes;
  590.      break;
  591.       case GL_PERSPECTIVE_CORRECTION_HINT:
  592.      *params = ENUM_TO_BOOL(CC.Hint.PerspectiveCorrection);
  593.      break;
  594.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  595.      *params = INT_TO_BOOL(CC.Pixel.MapAtoAsize);
  596.      break;
  597.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  598.      *params = INT_TO_BOOL(CC.Pixel.MapBtoBsize);
  599.      break;
  600.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  601.      *params = INT_TO_BOOL(CC.Pixel.MapGtoGsize);
  602.      break;
  603.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  604.      *params = INT_TO_BOOL(CC.Pixel.MapItoAsize);
  605.      break;
  606.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  607.      *params = INT_TO_BOOL(CC.Pixel.MapItoBsize);
  608.      break;
  609.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  610.      *params = INT_TO_BOOL(CC.Pixel.MapItoGsize);
  611.      break;
  612.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  613.      *params = INT_TO_BOOL(CC.Pixel.MapItoIsize);
  614.      break;
  615.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  616.      *params = INT_TO_BOOL(CC.Pixel.MapItoRsize);
  617.      break;
  618.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  619.      *params = INT_TO_BOOL(CC.Pixel.MapRtoRsize);
  620.      break;
  621.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  622.      *params = INT_TO_BOOL(CC.Pixel.MapStoSsize);
  623.      break;
  624.       case GL_POINT_SIZE:
  625.      *params = FLOAT_TO_BOOL(CC.Point.Size );
  626.      break;
  627.       case GL_POINT_SIZE_GRANULARITY:
  628.      *params = FLOAT_TO_BOOL(POINT_SIZE_GRANULARITY );
  629.      break;
  630.       case GL_POINT_SIZE_RANGE:
  631.      params[0] = FLOAT_TO_BOOL(MIN_POINT_SIZE );
  632.      params[1] = FLOAT_TO_BOOL(MAX_POINT_SIZE );
  633.      break;
  634.       case GL_POINT_SMOOTH:
  635.      *params = CC.Point.SmoothFlag;
  636.      break;
  637.       case GL_POINT_SMOOTH_HINT:
  638.      *params = ENUM_TO_BOOL(CC.Hint.PointSmooth);
  639.      break;
  640.       case GL_POLYGON_MODE:
  641.      params[0] = ENUM_TO_BOOL(CC.Polygon.FrontMode);
  642.      params[1] = ENUM_TO_BOOL(CC.Polygon.BackMode);
  643.      break;
  644.       case GL_POLYGON_OFFSET_BIAS_EXT:
  645.          *params = FLOAT_TO_BOOL( CC.Polygon.OffsetBias );
  646.          break;
  647.       case GL_POLYGON_OFFSET_FACTOR_EXT:
  648.          *params = FLOAT_TO_BOOL( CC.Polygon.OffsetFactor );
  649.          break;
  650.       case GL_POLYGON_SMOOTH:
  651.      *params = CC.Polygon.SmoothFlag;
  652.      break;
  653.       case GL_POLYGON_SMOOTH_HINT:
  654.      *params = ENUM_TO_BOOL(CC.Hint.PolygonSmooth);
  655.      break;
  656.       case GL_POLYGON_STIPPLE:
  657.      *params = CC.Polygon.StippleFlag;
  658.      break;
  659.       case GL_PROJECTION_MATRIX:
  660.      for (i=0;i<16;i++) {
  661.         params[i] = FLOAT_TO_BOOL(CC.ProjectionMatrix[i]);
  662.      }
  663.      break;
  664.       case GL_PROJECTION_STACK_DEPTH:
  665.      *params = INT_TO_BOOL(CC.ProjectionStackDepth);
  666.      break;
  667.       case GL_READ_BUFFER:
  668.      *params = ENUM_TO_BOOL(CC.Pixel.ReadBuffer);
  669.      break;
  670.       case GL_RED_BIAS:
  671.          *params = FLOAT_TO_BOOL(CC.Pixel.RedBias);
  672.      break;
  673.       case GL_RED_BITS:
  674.          *params = INT_TO_BOOL( bits( CC.RedScale ) );
  675.      break;
  676.       case GL_RED_SCALE:
  677.          *params = FLOAT_TO_BOOL(CC.Pixel.RedScale);
  678.      break;
  679.       case GL_RENDER_MODE:
  680.      *params = ENUM_TO_BOOL(CC.RenderMode);
  681.      break;
  682.       case GL_RGBA_MODE:
  683.          *params = CC.RGBAflag;
  684.      break;
  685.       case GL_SCISSOR_BOX:
  686.      params[0] = INT_TO_BOOL(CC.Scissor.X);
  687.      params[1] = INT_TO_BOOL(CC.Scissor.Y);
  688.      params[2] = INT_TO_BOOL(CC.Scissor.Width);
  689.      params[3] = INT_TO_BOOL(CC.Scissor.Height);
  690.      break;
  691.       case GL_SCISSOR_TEST:
  692.      *params = CC.Scissor.Enabled;
  693.      break;
  694.       case GL_SHADE_MODEL:
  695.      *params = ENUM_TO_BOOL(CC.Light.ShadeModel);
  696.      break;
  697.       case GL_STENCIL_BITS:
  698.      *params = INT_TO_BOOL(STENCIL_BITS);
  699.      break;
  700.       case GL_STENCIL_CLEAR_VALUE:
  701.      *params = INT_TO_BOOL(CC.Stencil.Clear);
  702.      break;
  703.       case GL_STENCIL_FAIL:
  704.      *params = ENUM_TO_BOOL(CC.Stencil.FailFunc);
  705.      break;
  706.       case GL_STENCIL_FUNC:
  707.      *params = ENUM_TO_BOOL(CC.Stencil.Function);
  708.      break;
  709.       case GL_STENCIL_PASS_DEPTH_FAIL:
  710.      *params = ENUM_TO_BOOL(CC.Stencil.ZFailFunc);
  711.      break;
  712.       case GL_STENCIL_PASS_DEPTH_PASS:
  713.      *params = ENUM_TO_BOOL(CC.Stencil.ZPassFunc);
  714.      break;
  715.       case GL_STENCIL_REF:
  716.      *params = INT_TO_BOOL(CC.Stencil.Ref);
  717.      break;
  718.       case GL_STENCIL_TEST:
  719.      *params = CC.Stencil.Enabled;
  720.      break;
  721.       case GL_STENCIL_VALUE_MASK:
  722.      *params = INT_TO_BOOL(CC.Stencil.ValueMask);
  723.      break;
  724.       case GL_STENCIL_WRITEMASK:
  725.      *params = INT_TO_BOOL(CC.Stencil.WriteMask);
  726.      break;
  727.       case GL_STEREO:
  728.      *params = GL_FALSE;    /* TODO */
  729.      break;
  730.       case GL_SUBPIXEL_BITS:
  731.      *params = INT_TO_BOOL(0);  /* TODO */
  732.      break;
  733.       case GL_TEXTURE_1D:
  734.      *params = (CC.Texture.Enabled & 1) ? GL_TRUE : GL_FALSE;
  735.      break;
  736.       case GL_TEXTURE_2D:
  737.      *params = (CC.Texture.Enabled & 2) ? GL_TRUE : GL_FALSE;
  738.      break;
  739.       case GL_TEXTURE_ENV_COLOR:
  740.      params[0] = FLOAT_TO_BOOL(CC.Texture.EnvColor[0]);
  741.      params[1] = FLOAT_TO_BOOL(CC.Texture.EnvColor[1]);
  742.      params[2] = FLOAT_TO_BOOL(CC.Texture.EnvColor[2]);
  743.      params[3] = FLOAT_TO_BOOL(CC.Texture.EnvColor[3]);
  744.      break;
  745.       case GL_TEXTURE_ENV_MODE:
  746.      *params = ENUM_TO_BOOL(CC.Texture.EnvMode);
  747.      break;
  748.       case GL_TEXTURE_GEN_S:
  749.      *params = (CC.Texture.TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
  750.      break;
  751.       case GL_TEXTURE_GEN_T:
  752.      *params = (CC.Texture.TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
  753.      break;
  754.       case GL_TEXTURE_GEN_R:
  755.      *params = (CC.Texture.TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
  756.      break;
  757.       case GL_TEXTURE_GEN_Q:
  758.      *params = (CC.Texture.TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
  759.      break;
  760.       case GL_TEXTURE_MATRIX:
  761.      for (i=0;i<16;i++) {
  762.         params[i] = FLOAT_TO_BOOL(CC.TextureMatrix[i]);
  763.      }
  764.      break;
  765.       case GL_TEXTURE_STACK_DEPTH:
  766.      *params = INT_TO_BOOL(CC.TextureStackDepth);
  767.      break;
  768.       case GL_UNPACK_ALIGNMENT:
  769.      *params = INT_TO_BOOL(CC.UnpackAlignment);
  770.      break;
  771.       case GL_UNPACK_LSB_FIRST:
  772.      *params = CC.UnpackLSBFirst;
  773.      break;
  774.       case GL_UNPACK_ROW_LENGTH:
  775.      *params = INT_TO_BOOL(CC.UnpackRowLength);
  776.      break;
  777.       case GL_UNPACK_SKIP_PIXELS:
  778.      *params = INT_TO_BOOL(CC.UnpackSkipPixels);
  779.      break;
  780.       case GL_UNPACK_SKIP_ROWS:
  781.      *params = INT_TO_BOOL(CC.UnpackSkipRows);
  782.      break;
  783.       case GL_UNPACK_SWAP_BYTES:
  784.      *params = CC.UnpackSwapBytes;
  785.      break;
  786.       case GL_VIEWPORT:
  787.      params[0] = INT_TO_BOOL(CC.Viewport.X);
  788.      params[1] = INT_TO_BOOL(CC.Viewport.Y);
  789.      params[2] = INT_TO_BOOL(CC.Viewport.Width);
  790.      params[3] = INT_TO_BOOL(CC.Viewport.Height);
  791.      break;
  792.       case GL_ZOOM_X:
  793.      *params = FLOAT_TO_BOOL(CC.Pixel.ZoomX);
  794.      break;
  795.       case GL_ZOOM_Y:
  796.      *params = FLOAT_TO_BOOL(CC.Pixel.ZoomY);
  797.      break;
  798.  
  799.       default:
  800.          gl_error( GL_INVALID_ENUM, "glGetBooleanv" );
  801.    }
  802. }
  803.  
  804.  
  805.  
  806.  
  807. void glGetDoublev( GLenum pname, GLdouble *params )
  808. {
  809.    GLuint i;
  810.  
  811.    if (INSIDE_BEGIN_END) {
  812.       gl_error( GL_INVALID_OPERATION, "glGetDoublev" );
  813.       return;
  814.    }
  815.  
  816.    switch (pname) {
  817.       case GL_ACCUM_RED_BITS:
  818.       case GL_ACCUM_GREEN_BITS:
  819.       case GL_ACCUM_BLUE_BITS:
  820.       case GL_ACCUM_ALPHA_BITS:
  821.          *params = (GLdouble) (sizeof(ACC_TYPE)*8);
  822.          break;
  823.       case GL_ACCUM_CLEAR_VALUE:
  824.          params[0] = (GLdouble) CC.Accum.ClearColor[0];
  825.          params[1] = (GLdouble) CC.Accum.ClearColor[1];
  826.          params[2] = (GLdouble) CC.Accum.ClearColor[2];
  827.          params[3] = (GLdouble) CC.Accum.ClearColor[3];
  828.          break;
  829.       case GL_ALPHA_BIAS:
  830.          *params = (GLdouble) CC.Pixel.AlphaBias;
  831.          break;
  832.       case GL_ALPHA_BITS:
  833.          *params = (GLdouble) bits( CC.AlphaScale );
  834.          break;
  835.       case GL_ALPHA_SCALE:
  836.          *params = (GLdouble) CC.Pixel.AlphaScale;
  837.          break;
  838.       case GL_ALPHA_TEST:
  839.          *params = (GLdouble) CC.Color.AlphaEnabled;
  840.          break;
  841.       case GL_ALPHA_TEST_FUNC:
  842.          *params = (GLdouble) CC.Color.AlphaFunc;
  843.          break;
  844.       case GL_ALPHA_TEST_REF:
  845.          *params = (GLdouble) CC.Color.AlphaRef;
  846.          break;
  847.       case GL_ATTRIB_STACK_DEPTH:
  848.          *params = (GLdouble ) CC.AttribStackDepth;
  849.          break;
  850.       case GL_AUTO_NORMAL:
  851.          *params = (GLdouble) CC.Eval.AutoNormal;
  852.          break;
  853.       case GL_AUX_BUFFERS:
  854.          *params = (GLdouble) NUM_AUX_BUFFERS;
  855.          break;
  856.       case GL_BLEND:
  857.          *params = (GLdouble) CC.Color.BlendEnabled;
  858.          break;
  859.       case GL_BLEND_DST:
  860.          *params = (GLdouble) CC.Color.BlendDst;
  861.          break;
  862.       case GL_BLEND_SRC:
  863.          *params = (GLdouble) CC.Color.BlendSrc;
  864.          break;
  865.       case GL_BLEND_EQUATION_EXT:
  866.      *params = (GLdouble) CC.Color.BlendEquation;
  867.      break;
  868.       case GL_BLEND_COLOR_EXT:
  869.      params[0] = (GLdouble) CC.Color.BlendColor[0];
  870.      params[1] = (GLdouble) CC.Color.BlendColor[1];
  871.      params[2] = (GLdouble) CC.Color.BlendColor[2];
  872.      params[3] = (GLdouble) CC.Color.BlendColor[3];
  873.      break;
  874.       case GL_BLUE_BIAS:
  875.          *params = (GLdouble) CC.Pixel.BlueBias;
  876.          break;
  877.       case GL_BLUE_BITS:
  878.          *params = (GLdouble) bits( CC.BlueScale );
  879.          break;
  880.       case GL_BLUE_SCALE:
  881.          *params = (GLdouble) CC.Pixel.BlueScale;
  882.          break;
  883.       case GL_CLIP_PLANE0:
  884.       case GL_CLIP_PLANE1:
  885.       case GL_CLIP_PLANE2:
  886.       case GL_CLIP_PLANE3:
  887.       case GL_CLIP_PLANE4:
  888.       case GL_CLIP_PLANE5:
  889.          *params = (GLdouble) CC.Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  890.          break;
  891.       case GL_COLOR_CLEAR_VALUE:
  892.          params[0] = (GLdouble) CC.Color.ClearColor[0];
  893.          params[1] = (GLdouble) CC.Color.ClearColor[1];
  894.          params[2] = (GLdouble) CC.Color.ClearColor[2];
  895.          params[3] = (GLdouble) CC.Color.ClearColor[3];
  896.          break;
  897.       case GL_COLOR_MATERIAL:
  898.          *params = (GLdouble) CC.Light.ColorMaterialEnabled;
  899.          break;
  900.       case GL_COLOR_MATERIAL_FACE:
  901.          *params = (GLdouble) CC.Light.ColorMaterialFace;
  902.          break;
  903.       case GL_COLOR_MATERIAL_PARAMETER:
  904.          *params = (GLdouble) CC.Light.ColorMaterialMode;
  905.          break;
  906.       case GL_COLOR_WRITEMASK:
  907.          params[0] = (CC.Color.ColorMask & 8) ? 1.0 : 0.0;
  908.          params[1] = (CC.Color.ColorMask & 4) ? 1.0 : 0.0;
  909.          params[2] = (CC.Color.ColorMask & 2) ? 1.0 : 0.0;
  910.          params[3] = (CC.Color.ColorMask & 1) ? 1.0 : 0.0;
  911.          break;
  912.       case GL_CULL_FACE:
  913.          *params = (GLdouble) CC.Polygon.CullFlag;
  914.          break;
  915.       case GL_CULL_FACE_MODE:
  916.          *params = (GLdouble) CC.Polygon.CullFaceMode;
  917.          break;
  918.       case GL_CURRENT_COLOR:
  919.          params[0] = (GLdouble) CC.Current.Color[0];
  920.          params[1] = (GLdouble) CC.Current.Color[1];
  921.          params[2] = (GLdouble) CC.Current.Color[2];
  922.          params[3] = (GLdouble) CC.Current.Color[3];
  923.          break;
  924.       case GL_CURRENT_INDEX:
  925.          *params = (GLdouble) CC.Current.Index;
  926.          break;
  927.       case GL_CURRENT_NORMAL:
  928.          params[0] = (GLdouble) CC.Current.Normal[0];
  929.          params[1] = (GLdouble) CC.Current.Normal[1];
  930.          params[2] = (GLdouble) CC.Current.Normal[2];
  931.          break;
  932.       case GL_CURRENT_RASTER_COLOR:
  933.      params[0] = (GLdouble) CC.Current.RasterColor[0];
  934.      params[1] = (GLdouble) CC.Current.RasterColor[1];
  935.      params[2] = (GLdouble) CC.Current.RasterColor[2];
  936.      params[3] = (GLdouble) CC.Current.RasterColor[3];
  937.      break;
  938.       case GL_CURRENT_RASTER_DISTANCE:
  939.      params[0] = (GLdouble) CC.Current.RasterDistance;
  940.      break;
  941.       case GL_CURRENT_RASTER_INDEX:
  942.      *params = (GLdouble) CC.Current.RasterIndex;
  943.      break;
  944.       case GL_CURRENT_RASTER_POSITION:
  945.      params[0] = (GLdouble) CC.Current.RasterPos[0];
  946.      params[1] = (GLdouble) CC.Current.RasterPos[1];
  947.      params[2] = (GLdouble) CC.Current.RasterPos[2];
  948.      params[3] = (GLdouble) CC.Current.RasterPos[3];
  949.      break;
  950.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  951.      params[0] = (GLdouble) CC.Current.RasterTexCoord[0];
  952.      params[1] = (GLdouble) CC.Current.RasterTexCoord[1];
  953.      params[2] = (GLdouble) CC.Current.RasterTexCoord[2];
  954.      params[3] = (GLdouble) CC.Current.RasterTexCoord[3];
  955.      break;
  956.       case GL_CURRENT_RASTER_POSITION_VALID:
  957.      *params = (GLdouble) CC.Current.RasterPosValid;
  958.      break;
  959.       case GL_CURRENT_TEXTURE_COORDS:
  960.      params[0] = (GLdouble) CC.Current.TexCoord[0];
  961.      params[1] = (GLdouble) CC.Current.TexCoord[1];
  962.      params[2] = (GLdouble) CC.Current.TexCoord[2];
  963.      params[3] = (GLdouble) CC.Current.TexCoord[3];
  964.      break;
  965.       case GL_DEPTH_BIAS:
  966.      *params = (GLdouble) CC.Pixel.DepthBias;
  967.      break;
  968.       case GL_DEPTH_BITS:
  969.      *params = (GLdouble) (8*sizeof(GLint));
  970.      break;
  971.       case GL_DEPTH_CLEAR_VALUE:
  972.      *params = (GLdouble) CC.Depth.Clear;
  973.      break;
  974.       case GL_DEPTH_FUNC:
  975.      *params = (GLdouble) CC.Depth.Func;
  976.      break;
  977.       case GL_DEPTH_RANGE:
  978.          params[0] = (GLdouble) CC.Viewport.Near;
  979.          params[1] = (GLdouble) CC.Viewport.Far;
  980.      break;
  981.       case GL_DEPTH_SCALE:
  982.      *params = (GLdouble) CC.Pixel.DepthScale;
  983.      break;
  984.       case GL_DEPTH_TEST:
  985.      *params = (GLdouble) CC.Depth.Test;
  986.      break;
  987.       case GL_DEPTH_WRITEMASK:
  988.      *params = (GLdouble) CC.Depth.Mask;
  989.      break;
  990.       case GL_DITHER:
  991.      *params = (GLdouble) CC.Color.DitherFlag;
  992.      break;
  993.       case GL_DOUBLEBUFFER:
  994.      *params = (GLdouble) CC.DBflag;
  995.      break;
  996.       case GL_DRAW_BUFFER:
  997.      *params = (GLdouble) CC.Color.DrawBuffer;
  998.      break;
  999.       case GL_EDGE_FLAG:
  1000.      *params = (GLdouble) CC.Current.EdgeFlag;
  1001.      break;
  1002.       case GL_FOG:
  1003.      *params = (GLdouble) CC.Fog.Enabled;
  1004.      break;
  1005.       case GL_FOG_COLOR:
  1006.      params[0] = (GLdouble) CC.Fog.Color[0];
  1007.      params[1] = (GLdouble) CC.Fog.Color[1];
  1008.      params[2] = (GLdouble) CC.Fog.Color[2];
  1009.      params[3] = (GLdouble) CC.Fog.Color[3];
  1010.      break;
  1011.       case GL_FOG_DENSITY:
  1012.      *params = (GLdouble) CC.Fog.Density;
  1013.      break;
  1014.       case GL_FOG_END:
  1015.      *params = (GLdouble) CC.Fog.End;
  1016.      break;
  1017.       case GL_FOG_HINT:
  1018.      *params = (GLdouble) CC.Hint.Fog;
  1019.      break;
  1020.       case GL_FOG_INDEX:
  1021.      *params = (GLdouble) CC.Fog.Index;
  1022.      break;
  1023.       case GL_FOG_MODE:
  1024.      *params = (GLdouble) CC.Fog.Mode;
  1025.      break;
  1026.       case GL_FOG_START:
  1027.      *params = (GLdouble) CC.Fog.Start;
  1028.      break;
  1029.       case GL_FRONT_FACE:
  1030.      *params = (GLdouble) CC.Polygon.FrontFace;
  1031.      break;
  1032.       case GL_GREEN_BIAS:
  1033.          *params = (GLdouble) CC.Pixel.GreenBias;
  1034.          break;
  1035.       case GL_GREEN_BITS:
  1036.          *params = (GLdouble) bits( CC.GreenScale );
  1037.          break;
  1038.       case GL_GREEN_SCALE:
  1039.          *params = (GLdouble) CC.Pixel.GreenScale;
  1040.          break;
  1041.       case GL_INDEX_BITS:
  1042.      {
  1043.         GLuint width, height, depth;
  1044.         (*DD.buffer_size)( &width, &height, &depth );
  1045.         *params = (GLdouble) depth;
  1046.      }
  1047.      break;
  1048.       case GL_INDEX_CLEAR_VALUE:
  1049.          *params = (GLdouble) CC.Color.ClearIndex;
  1050.      break;
  1051.       case GL_INDEX_MODE:
  1052.      *params = (GLdouble) CC.RGBAflag;
  1053.      break;
  1054.       case GL_INDEX_OFFSET:
  1055.      *params = (GLdouble) CC.Pixel.IndexOffset;
  1056.      break;
  1057.       case GL_INDEX_SHIFT:
  1058.      *params = (GLdouble) CC.Pixel.IndexShift;
  1059.      break;
  1060.       case GL_INDEX_WRITEMASK:
  1061.      *params = (GLdouble) CC.Color.IndexMask;
  1062.      break;
  1063.       case GL_LIGHT0:
  1064.       case GL_LIGHT1:
  1065.       case GL_LIGHT2:
  1066.       case GL_LIGHT3:
  1067.       case GL_LIGHT4:
  1068.       case GL_LIGHT5:
  1069.       case GL_LIGHT6:
  1070.       case GL_LIGHT7:
  1071.      *params = (GLdouble) CC.Light.Light[pname-GL_LIGHT0].Enabled;
  1072.      break;
  1073.       case GL_LIGHTING:
  1074.      *params = (GLdouble) CC.Light.Enabled;
  1075.      break;
  1076.       case GL_LIGHT_MODEL_AMBIENT:
  1077.      params[0] = (GLdouble) CC.Light.Model.Ambient[0];
  1078.      params[1] = (GLdouble) CC.Light.Model.Ambient[1];
  1079.      params[2] = (GLdouble) CC.Light.Model.Ambient[2];
  1080.      params[3] = (GLdouble) CC.Light.Model.Ambient[3];
  1081.      break;
  1082.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  1083.      *params = (GLdouble) CC.Light.Model.LocalViewer;
  1084.      break;
  1085.       case GL_LIGHT_MODEL_TWO_SIDE:
  1086.      *params = (GLdouble) CC.Light.Model.TwoSide;
  1087.      break;
  1088.       case GL_LINE_SMOOTH:
  1089.      *params = (GLdouble) CC.Line.SmoothFlag;
  1090.      break;
  1091.       case GL_LINE_SMOOTH_HINT:
  1092.      *params = (GLdouble) CC.Hint.LineSmooth;
  1093.      break;
  1094.       case GL_LINE_STIPPLE:
  1095.      *params = (GLdouble) CC.Line.StippleFlag;
  1096.      break;
  1097.       case GL_LINE_STIPPLE_PATTERN:
  1098.          *params = (GLdouble) CC.Line.StipplePattern;
  1099.          break;
  1100.       case GL_LINE_STIPPLE_REPEAT:
  1101.          *params = (GLdouble) CC.Line.StippleFactor;
  1102.          break;
  1103.       case GL_LINE_WIDTH:
  1104.      *params = (GLdouble) CC.Line.Width;
  1105.      break;
  1106.       case GL_LINE_WIDTH_GRANULARITY:
  1107.      *params = (GLdouble) LINE_WIDTH_GRANULARITY;
  1108.      break;
  1109.       case GL_LINE_WIDTH_RANGE:
  1110.      params[0] = (GLdouble) MIN_LINE_WIDTH;
  1111.      params[1] = (GLdouble) MAX_LINE_WIDTH;
  1112.      break;
  1113.       case GL_LIST_BASE:
  1114.      *params = (GLdouble) CC.List.ListBase;
  1115.      break;
  1116.       case GL_LIST_INDEX:
  1117.      *params = (GLdouble) gl_list_index();
  1118.      break;
  1119.       case GL_LIST_MODE:
  1120.      *params = CC.ExecuteFlag ? (GLdouble) GL_COMPILE_AND_EXECUTE
  1121.                      : (GLdouble) GL_COMPILE;
  1122.      break;
  1123.       case GL_LOGIC_OP:
  1124.      *params = (GLdouble) CC.Color.LogicOpEnabled;
  1125.      break;
  1126.       case GL_LOGIC_OP_MODE:
  1127.          *params = (GLdouble) CC.Color.LogicOp;
  1128.      break;
  1129.       case GL_MAP1_COLOR_4:
  1130.      *params = (GLdouble) CC.Eval.Map1Color4;
  1131.      break;
  1132.       case GL_MAP1_GRID_DOMAIN:
  1133.      params[0] = (GLdouble) CC.Eval.MapGrid1u1;
  1134.      params[1] = (GLdouble) CC.Eval.MapGrid1u2;
  1135.      break;
  1136.       case GL_MAP1_GRID_SEGMENTS:
  1137.      *params = (GLdouble) CC.Eval.MapGrid1un;
  1138.      break;
  1139.       case GL_MAP1_INDEX:
  1140.      *params = (GLdouble) CC.Eval.Map1Index;
  1141.      break;
  1142.       case GL_MAP1_NORMAL:
  1143.      *params = (GLdouble) CC.Eval.Map1Normal;
  1144.      break;
  1145.       case GL_MAP1_TEXTURE_COORD_1:
  1146.      *params = (GLdouble) CC.Eval.Map1TextureCoord1;
  1147.      break;
  1148.       case GL_MAP1_TEXTURE_COORD_2:
  1149.      *params = (GLdouble) CC.Eval.Map1TextureCoord2;
  1150.      break;
  1151.       case GL_MAP1_TEXTURE_COORD_3:
  1152.      *params = (GLdouble) CC.Eval.Map1TextureCoord3;
  1153.      break;
  1154.       case GL_MAP1_TEXTURE_COORD_4:
  1155.      *params = (GLdouble) CC.Eval.Map1TextureCoord4;
  1156.      break;
  1157.       case GL_MAP1_VERTEX_3:
  1158.      *params = (GLdouble) CC.Eval.Map1Vertex3;
  1159.      break;
  1160.       case GL_MAP1_VERTEX_4:
  1161.      *params = (GLdouble) CC.Eval.Map1Vertex4;
  1162.      break;
  1163.       case GL_MAP2_COLOR_4:
  1164.      *params = (GLdouble) CC.Eval.Map2Color4;
  1165.      break;
  1166.       case GL_MAP2_GRID_DOMAIN:
  1167.      params[0] = (GLdouble) CC.Eval.MapGrid2u1;
  1168.      params[1] = (GLdouble) CC.Eval.MapGrid2u2;
  1169.      params[2] = (GLdouble) CC.Eval.MapGrid2v1;
  1170.      params[3] = (GLdouble) CC.Eval.MapGrid2v2;
  1171.      break;
  1172.       case GL_MAP2_GRID_SEGMENTS:
  1173.      params[0] = (GLdouble) CC.Eval.MapGrid2un;
  1174.      params[1] = (GLdouble) CC.Eval.MapGrid2vn;
  1175.      break;
  1176.       case GL_MAP2_INDEX:
  1177.      *params = (GLdouble) CC.Eval.Map2Index;
  1178.      break;
  1179.       case GL_MAP2_NORMAL:
  1180.      *params = (GLdouble) CC.Eval.Map2Normal;
  1181.      break;
  1182.       case GL_MAP2_TEXTURE_COORD_1:
  1183.      *params = (GLdouble) CC.Eval.Map2TextureCoord1;
  1184.      break;
  1185.       case GL_MAP2_TEXTURE_COORD_2:
  1186.      *params = (GLdouble) CC.Eval.Map2TextureCoord2;
  1187.      break;
  1188.       case GL_MAP2_TEXTURE_COORD_3:
  1189.      *params = (GLdouble) CC.Eval.Map2TextureCoord3;
  1190.      break;
  1191.       case GL_MAP2_TEXTURE_COORD_4:
  1192.      *params = (GLdouble) CC.Eval.Map2TextureCoord4;
  1193.      break;
  1194.       case GL_MAP2_VERTEX_3:
  1195.      *params = (GLdouble) CC.Eval.Map2Vertex3;
  1196.      break;
  1197.       case GL_MAP2_VERTEX_4:
  1198.      *params = (GLdouble) CC.Eval.Map2Vertex4;
  1199.      break;
  1200.       case GL_MAP_COLOR:
  1201.      *params = (GLdouble) CC.Pixel.MapColorFlag;
  1202.      break;
  1203.       case GL_MAP_STENCIL:
  1204.      *params = (GLdouble) CC.Pixel.MapStencilFlag;
  1205.      break;
  1206.       case GL_MATRIX_MODE:
  1207.      *params = (GLdouble) CC.Transform.MatrixMode;
  1208.      break;
  1209.       case GL_MAX_ATTRIB_STACK_DEPTH:
  1210.      *params = (GLdouble) MAX_ATTRIB_STACK_DEPTH;
  1211.      break;
  1212.       case GL_MAX_CLIP_PLANES:
  1213.      *params = (GLdouble) MAX_CLIP_PLANES;
  1214.      break;
  1215.       case GL_MAX_EVAL_ORDER:
  1216.      *params = (GLdouble) MAX_EVAL_ORDER;
  1217.      break;
  1218.       case GL_MAX_LIGHTS:
  1219.      *params = (GLdouble) MAX_LIGHTS;
  1220.      break;
  1221.       case GL_MAX_LIST_NESTING:
  1222.      *params = (GLdouble) MAX_LIST_NESTING;
  1223.      break;
  1224.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  1225.      *params = (GLdouble) MAX_MODELVIEW_STACK_DEPTH;
  1226.      break;
  1227.       case GL_MAX_NAME_STACK_DEPTH:
  1228.      *params = (GLdouble) MAX_NAME_STACK_DEPTH;
  1229.      break;
  1230.       case GL_MAX_PIXEL_MAP_TABLE:
  1231.      *params = (GLdouble) MAX_PIXEL_MAP_TABLE;
  1232.      break;
  1233.       case GL_MAX_PROJECTION_STACK_DEPTH:
  1234.      *params = (GLdouble) MAX_PROJECTION_STACK_DEPTH;
  1235.      break;
  1236.       case GL_MAX_TEXTURE_SIZE:
  1237.      *params = (GLdouble) MAX_TEXTURE_SIZE;
  1238.      break;
  1239.       case GL_MAX_TEXTURE_STACK_DEPTH:
  1240.      *params = (GLdouble) MAX_TEXTURE_STACK_DEPTH;
  1241.      break;
  1242.       case GL_MAX_VIEWPORT_DIMS:
  1243.          params[0] = (GLdouble) MAX_WIDTH;
  1244.          params[1] = (GLdouble) MAX_HEIGHT;
  1245.          break;
  1246.       case GL_MODELVIEW_MATRIX:
  1247.      for (i=0;i<16;i++) {
  1248.         params[i] = (GLdouble) CC.ModelViewMatrix[i];
  1249.      }
  1250.      break;
  1251.       case GL_MODELVIEW_STACK_DEPTH:
  1252.      *params = (GLdouble) CC.ModelViewStackDepth;
  1253.      break;
  1254.       case GL_NAME_STACK_DEPTH:
  1255.      *params = (GLdouble) CC.NameStackDepth;
  1256.      break;
  1257.       case GL_NORMALIZE:
  1258.      *params = (GLdouble) CC.Transform.Normalize;
  1259.      break;
  1260.       case GL_PACK_ALIGNMENT:
  1261.      *params = (GLdouble) CC.PackAlignment;
  1262.      break;
  1263.       case GL_PACK_LSB_FIRST:
  1264.      *params = (GLdouble) CC.PackLSBFirst;
  1265.      break;
  1266.       case GL_PACK_ROW_LENGTH:
  1267.      *params = (GLdouble) CC.PackRowLength;
  1268.      break;
  1269.       case GL_PACK_SKIP_PIXELS:
  1270.      *params = (GLdouble) CC.PackSkipPixels;
  1271.      break;
  1272.       case GL_PACK_SKIP_ROWS:
  1273.      *params = (GLdouble) CC.PackSkipRows;
  1274.      break;
  1275.       case GL_PACK_SWAP_BYTES:
  1276.      *params = (GLdouble) CC.PackSwapBytes;
  1277.      break;
  1278.       case GL_PERSPECTIVE_CORRECTION_HINT:
  1279.      *params = (GLdouble) CC.Hint.PerspectiveCorrection;
  1280.      break;
  1281.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  1282.      *params = (GLdouble) CC.Pixel.MapAtoAsize;
  1283.      break;
  1284.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  1285.      *params = (GLdouble) CC.Pixel.MapBtoBsize;
  1286.      break;
  1287.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  1288.      *params = (GLdouble) CC.Pixel.MapGtoGsize;
  1289.      break;
  1290.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  1291.      *params = (GLdouble) CC.Pixel.MapItoAsize;
  1292.      break;
  1293.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  1294.      *params = (GLdouble) CC.Pixel.MapItoBsize;
  1295.      break;
  1296.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  1297.      *params = (GLdouble) CC.Pixel.MapItoGsize;
  1298.      break;
  1299.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  1300.      *params = (GLdouble) CC.Pixel.MapItoIsize;
  1301.      break;
  1302.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  1303.      *params = (GLdouble) CC.Pixel.MapItoRsize;
  1304.      break;
  1305.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  1306.      *params = (GLdouble) CC.Pixel.MapRtoRsize;
  1307.      break;
  1308.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  1309.      *params = (GLdouble) CC.Pixel.MapStoSsize;
  1310.      break;
  1311.       case GL_POINT_SIZE:
  1312.          *params = (GLdouble) CC.Point.Size;
  1313.          break;
  1314.       case GL_POINT_SIZE_GRANULARITY:
  1315.      *params = (GLdouble) POINT_SIZE_GRANULARITY;
  1316.      break;
  1317.       case GL_POINT_SIZE_RANGE:
  1318.      params[0] = (GLdouble) MIN_POINT_SIZE;
  1319.      params[1] = (GLdouble) MAX_POINT_SIZE;
  1320.      break;
  1321.       case GL_POINT_SMOOTH:
  1322.      *params = (GLdouble) CC.Point.SmoothFlag;
  1323.      break;
  1324.       case GL_POINT_SMOOTH_HINT:
  1325.      *params = (GLdouble) CC.Hint.PointSmooth;
  1326.      break;
  1327.       case GL_POLYGON_MODE:
  1328.      params[0] = (GLdouble) CC.Polygon.FrontMode;
  1329.      params[1] = (GLdouble) CC.Polygon.BackMode;
  1330.      break;
  1331.       case GL_POLYGON_OFFSET_BIAS_EXT:
  1332.          *params = (GLdouble) CC.Polygon.OffsetBias;
  1333.          break;
  1334.       case GL_POLYGON_OFFSET_FACTOR_EXT:
  1335.          *params = (GLdouble) CC.Polygon.OffsetFactor;
  1336.          break;
  1337.       case GL_POLYGON_SMOOTH:
  1338.      *params = (GLdouble) CC.Polygon.SmoothFlag;
  1339.      break;
  1340.       case GL_POLYGON_SMOOTH_HINT:
  1341.      *params = (GLdouble) CC.Hint.PolygonSmooth;
  1342.      break;
  1343.       case GL_POLYGON_STIPPLE:
  1344.      for (i=0;i<32;i++) {        /* RIGHT? */
  1345.         params[i] = (GLdouble) CC.PolygonStipple[i];
  1346.      }
  1347.      break;
  1348.       case GL_PROJECTION_MATRIX:
  1349.      for (i=0;i<16;i++) {
  1350.         params[i] = (GLdouble) CC.ProjectionMatrix[i];
  1351.      }
  1352.      break;
  1353.       case GL_PROJECTION_STACK_DEPTH:
  1354.      *params = (GLdouble) CC.ProjectionStackDepth;
  1355.      break;
  1356.       case GL_READ_BUFFER:
  1357.      *params = (GLdouble) CC.Pixel.ReadBuffer;
  1358.      break;
  1359.       case GL_RED_BIAS:
  1360.          *params = (GLdouble) CC.Pixel.RedBias;
  1361.          break;
  1362.       case GL_RED_BITS:
  1363.          *params = (GLdouble) bits( CC.RedScale );
  1364.          break;
  1365.       case GL_RED_SCALE:
  1366.          *params = (GLdouble) CC.Pixel.RedScale;
  1367.          break;
  1368.       case GL_RENDER_MODE:
  1369.      *params = (GLdouble) CC.RenderMode;
  1370.      break;
  1371.       case GL_RGBA_MODE:
  1372.      *params = (GLdouble) CC.RGBAflag;
  1373.      break;
  1374.       case GL_SCISSOR_BOX:
  1375.      params[0] = (GLdouble) CC.Scissor.X;
  1376.      params[1] = (GLdouble) CC.Scissor.Y;
  1377.      params[2] = (GLdouble) CC.Scissor.Width;
  1378.      params[3] = (GLdouble) CC.Scissor.Height;
  1379.      break;
  1380.       case GL_SCISSOR_TEST:
  1381.      *params = (GLdouble) CC.Scissor.Enabled;
  1382.      break;
  1383.       case GL_SHADE_MODEL:
  1384.      *params = (GLdouble) CC.Light.ShadeModel;
  1385.      break;
  1386.       case GL_STENCIL_BITS:
  1387.          *params = (GLdouble) STENCIL_BITS;
  1388.          break;
  1389.       case GL_STENCIL_CLEAR_VALUE:
  1390.      *params = (GLdouble) CC.Stencil.Clear;
  1391.      break;
  1392.       case GL_STENCIL_FAIL:
  1393.      *params = (GLdouble) CC.Stencil.FailFunc;
  1394.      break;
  1395.       case GL_STENCIL_FUNC:
  1396.      *params = (GLdouble) CC.Stencil.Function;
  1397.      break;
  1398.       case GL_STENCIL_PASS_DEPTH_FAIL:
  1399.      *params = (GLdouble) CC.Stencil.ZFailFunc;
  1400.      break;
  1401.       case GL_STENCIL_PASS_DEPTH_PASS:
  1402.      *params = (GLdouble) CC.Stencil.ZPassFunc;
  1403.      break;
  1404.       case GL_STENCIL_REF:
  1405.      *params = (GLdouble) CC.Stencil.Ref;
  1406.      break;
  1407.       case GL_STENCIL_TEST:
  1408.      *params = (GLdouble) CC.Stencil.Enabled;
  1409.      break;
  1410.       case GL_STENCIL_VALUE_MASK:
  1411.      *params = (GLdouble) CC.Stencil.ValueMask;
  1412.      break;
  1413.       case GL_STENCIL_WRITEMASK:
  1414.      *params = (GLdouble) CC.Stencil.WriteMask;
  1415.      break;
  1416.       case GL_STEREO:
  1417.      *params = 0.0;   /* TODO */
  1418.      break;
  1419.       case GL_SUBPIXEL_BITS:
  1420.      *params = 0.0;   /* TODO */
  1421.      break;
  1422.       case GL_TEXTURE_1D:
  1423.      *params = (CC.Texture.Enabled & 1) ? 1.0 : 0.0;
  1424.      break;
  1425.       case GL_TEXTURE_2D:
  1426.      *params = (CC.Texture.Enabled & 2) ? 1.0 : 0.0;
  1427.      break;
  1428.       case GL_TEXTURE_ENV_COLOR:
  1429.      params[0] = (GLdouble) CC.Texture.EnvColor[0];
  1430.      params[1] = (GLdouble) CC.Texture.EnvColor[1];
  1431.      params[2] = (GLdouble) CC.Texture.EnvColor[2];
  1432.      params[3] = (GLdouble) CC.Texture.EnvColor[3];
  1433.      break;
  1434.       case GL_TEXTURE_ENV_MODE:
  1435.      *params = (GLdouble) CC.Texture.EnvMode;
  1436.      break;
  1437.       case GL_TEXTURE_GEN_S:
  1438.      *params = (CC.Texture.TexGenEnabled & S_BIT) ? 1.0 : 0.0;
  1439.      break;
  1440.       case GL_TEXTURE_GEN_T:
  1441.      *params = (CC.Texture.TexGenEnabled & T_BIT) ? 1.0 : 0.0;
  1442.      break;
  1443.       case GL_TEXTURE_GEN_R:
  1444.      *params = (CC.Texture.TexGenEnabled & R_BIT) ? 1.0 : 0.0;
  1445.      break;
  1446.       case GL_TEXTURE_GEN_Q:
  1447.      *params = (CC.Texture.TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
  1448.      break;
  1449.       case GL_TEXTURE_MATRIX:
  1450.          for (i=0;i<16;i++) {
  1451.         params[i] = (GLdouble) CC.TextureMatrix[i];
  1452.      }
  1453.      break;
  1454.       case GL_TEXTURE_STACK_DEPTH:
  1455.      *params = (GLdouble) CC.TextureStackDepth;
  1456.      break;
  1457.       case GL_UNPACK_ALIGNMENT:
  1458.      *params = (GLdouble) CC.UnpackAlignment;
  1459.      break;
  1460.       case GL_UNPACK_LSB_FIRST:
  1461.      *params = (GLdouble) CC.UnpackLSBFirst;
  1462.      break;
  1463.       case GL_UNPACK_ROW_LENGTH:
  1464.      *params = (GLdouble) CC.UnpackRowLength;
  1465.      break;
  1466.       case GL_UNPACK_SKIP_PIXELS:
  1467.      *params = (GLdouble) CC.UnpackSkipPixels;
  1468.      break;
  1469.       case GL_UNPACK_SKIP_ROWS:
  1470.      *params = (GLdouble) CC.UnpackSkipRows;
  1471.      break;
  1472.       case GL_UNPACK_SWAP_BYTES:
  1473.      *params = (GLdouble) CC.UnpackSwapBytes;
  1474.      break;
  1475.       case GL_VIEWPORT:
  1476.      params[0] = (GLdouble) CC.Viewport.X;
  1477.      params[1] = (GLdouble) CC.Viewport.Y;
  1478.      params[2] = (GLdouble) CC.Viewport.Width;
  1479.      params[3] = (GLdouble) CC.Viewport.Height;
  1480.      break;
  1481.       case GL_ZOOM_X:
  1482.      *params = (GLdouble) CC.Pixel.ZoomX;
  1483.      break;
  1484.       case GL_ZOOM_Y:
  1485.      *params = (GLdouble) CC.Pixel.ZoomY;
  1486.      break;
  1487.       default:
  1488.          gl_error( GL_INVALID_ENUM, "glGetDoublev" );
  1489.    }
  1490. }
  1491.  
  1492.  
  1493.  
  1494.  
  1495. void glGetFloatv( GLenum pname, GLfloat *params )
  1496. {
  1497.    GLuint i;
  1498.  
  1499.    if (INSIDE_BEGIN_END) {
  1500.       gl_error( GL_INVALID_OPERATION, "glGetFloatv" );
  1501.       return;
  1502.    }
  1503.    switch (pname) {
  1504.       case GL_ACCUM_RED_BITS:
  1505.       case GL_ACCUM_GREEN_BITS:
  1506.       case GL_ACCUM_BLUE_BITS:
  1507.       case GL_ACCUM_ALPHA_BITS:
  1508.          *params = (GLfloat) (sizeof(ACC_TYPE)*8);
  1509.          break;
  1510.       case GL_ACCUM_CLEAR_VALUE:
  1511.          params[0] = CC.Accum.ClearColor[0];
  1512.          params[1] = CC.Accum.ClearColor[1];
  1513.          params[2] = CC.Accum.ClearColor[2];
  1514.          params[3] = CC.Accum.ClearColor[3];
  1515.          break;
  1516.       case GL_ALPHA_BIAS:
  1517.          *params = CC.Pixel.AlphaBias;
  1518.          break;
  1519.       case GL_ALPHA_BITS:
  1520.          *params = (GLfloat) bits( CC.AlphaScale );
  1521.          break;
  1522.       case GL_ALPHA_SCALE:
  1523.          *params = CC.Pixel.AlphaScale;
  1524.          break;
  1525.       case GL_ALPHA_TEST:
  1526.          *params = (GLfloat) CC.Color.AlphaEnabled;
  1527.          break;
  1528.       case GL_ALPHA_TEST_FUNC:
  1529.          *params = (GLfloat) CC.Color.AlphaFunc;
  1530.          break;
  1531.       case GL_ALPHA_TEST_REF:
  1532.          *params = (GLfloat) CC.Color.AlphaRef;
  1533.          break;
  1534.       case GL_ATTRIB_STACK_DEPTH:
  1535.          *params = (GLfloat ) CC.AttribStackDepth;
  1536.          break;
  1537.       case GL_AUTO_NORMAL:
  1538.          *params = (GLfloat) CC.Eval.AutoNormal;
  1539.          break;
  1540.       case GL_AUX_BUFFERS:
  1541.          *params = (GLfloat) NUM_AUX_BUFFERS;
  1542.          break;
  1543.       case GL_BLEND:
  1544.          *params = (GLfloat) CC.Color.BlendEnabled;
  1545.          break;
  1546.       case GL_BLEND_DST:
  1547.          *params = (GLfloat) CC.Color.BlendDst;
  1548.          break;
  1549.       case GL_BLEND_SRC:
  1550.          *params = (GLfloat) CC.Color.BlendSrc;
  1551.          break;
  1552.       case GL_BLEND_EQUATION_EXT:
  1553.      *params = (GLfloat) CC.Color.BlendEquation;
  1554.      break;
  1555.       case GL_BLEND_COLOR_EXT:
  1556.      params[0] = CC.Color.BlendColor[0];
  1557.      params[1] = CC.Color.BlendColor[1];
  1558.      params[2] = CC.Color.BlendColor[2];
  1559.      params[3] = CC.Color.BlendColor[3];
  1560.      break;
  1561.       case GL_BLUE_BIAS:
  1562.          *params = CC.Pixel.BlueBias;
  1563.          break;
  1564.       case GL_BLUE_BITS:
  1565.          *params = (GLfloat) bits( CC.BlueScale );
  1566.          break;
  1567.       case GL_BLUE_SCALE:
  1568.          *params = CC.Pixel.BlueScale;
  1569.          break;
  1570.       case GL_CLIP_PLANE0:
  1571.       case GL_CLIP_PLANE1:
  1572.       case GL_CLIP_PLANE2:
  1573.       case GL_CLIP_PLANE3:
  1574.       case GL_CLIP_PLANE4:
  1575.       case GL_CLIP_PLANE5:
  1576.          *params = (GLfloat) CC.Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  1577.          break;
  1578.       case GL_COLOR_CLEAR_VALUE:
  1579.          params[0] = (GLfloat) CC.Color.ClearColor[0];
  1580.          params[1] = (GLfloat) CC.Color.ClearColor[1];
  1581.          params[2] = (GLfloat) CC.Color.ClearColor[2];
  1582.          params[3] = (GLfloat) CC.Color.ClearColor[3];
  1583.          break;
  1584.       case GL_COLOR_MATERIAL:
  1585.          *params = (GLfloat) CC.Light.ColorMaterialEnabled;
  1586.          break;
  1587.       case GL_COLOR_MATERIAL_FACE:
  1588.          *params = (GLfloat) CC.Light.ColorMaterialFace;
  1589.          break;
  1590.       case GL_COLOR_MATERIAL_PARAMETER:
  1591.          *params = (GLfloat) CC.Light.ColorMaterialMode;
  1592.          break;
  1593.       case GL_COLOR_WRITEMASK:
  1594.          params[0] = (CC.Color.ColorMask & 8) ? 1.0F : 0.0F;
  1595.          params[1] = (CC.Color.ColorMask & 4) ? 1.0F : 0.0F;
  1596.          params[2] = (CC.Color.ColorMask & 2) ? 1.0F : 0.0F;
  1597.          params[3] = (CC.Color.ColorMask & 1) ? 1.0F : 0.0F;
  1598.          break;
  1599.       case GL_CULL_FACE:
  1600.          *params = (GLfloat) CC.Polygon.CullFlag;
  1601.          break;
  1602.       case GL_CULL_FACE_MODE:
  1603.          *params = (GLfloat) CC.Polygon.CullFaceMode;
  1604.          break;
  1605.       case GL_CURRENT_COLOR:
  1606.          params[0] = CC.Current.Color[0];
  1607.          params[1] = CC.Current.Color[1];
  1608.          params[2] = CC.Current.Color[2];
  1609.          params[3] = CC.Current.Color[3];
  1610.          break;
  1611.       case GL_CURRENT_INDEX:
  1612.          *params = (GLfloat) CC.Current.Index;
  1613.          break;
  1614.       case GL_CURRENT_NORMAL:
  1615.          params[0] = CC.Current.Normal[0];
  1616.          params[1] = CC.Current.Normal[1];
  1617.          params[2] = CC.Current.Normal[2];
  1618.          break;
  1619.       case GL_CURRENT_RASTER_COLOR:
  1620.      params[0] = CC.Current.RasterColor[0];
  1621.      params[1] = CC.Current.RasterColor[1];
  1622.      params[2] = CC.Current.RasterColor[2];
  1623.      params[3] = CC.Current.RasterColor[3];
  1624.      break;
  1625.       case GL_CURRENT_RASTER_DISTANCE:
  1626.      params[0] = CC.Current.RasterDistance;
  1627.      break;
  1628.       case GL_CURRENT_RASTER_INDEX:
  1629.      *params = (GLfloat) CC.Current.RasterIndex;
  1630.      break;
  1631.       case GL_CURRENT_RASTER_POSITION:
  1632.      params[0] = CC.Current.RasterPos[0];
  1633.      params[1] = CC.Current.RasterPos[1];
  1634.      params[2] = CC.Current.RasterPos[2];
  1635.      params[3] = CC.Current.RasterPos[3];
  1636.      break;
  1637.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  1638.      params[0] = CC.Current.RasterTexCoord[0];
  1639.      params[1] = CC.Current.RasterTexCoord[1];
  1640.      params[2] = CC.Current.RasterTexCoord[2];
  1641.      params[3] = CC.Current.RasterTexCoord[3];
  1642.      break;
  1643.       case GL_CURRENT_RASTER_POSITION_VALID:
  1644.      *params = (GLfloat) CC.Current.RasterPosValid;
  1645.      break;
  1646.       case GL_CURRENT_TEXTURE_COORDS:
  1647.      params[0] = (GLfloat) CC.Current.TexCoord[0];
  1648.      params[1] = (GLfloat) CC.Current.TexCoord[1];
  1649.      params[2] = (GLfloat) CC.Current.TexCoord[2];
  1650.      params[3] = (GLfloat) CC.Current.TexCoord[3];
  1651.      break;
  1652.       case GL_DEPTH_BIAS:
  1653.      *params = (GLfloat) CC.Pixel.DepthBias;
  1654.      break;
  1655.       case GL_DEPTH_BITS:
  1656.      *params = (GLfloat) (8*sizeof(GLint));
  1657.      break;
  1658.       case GL_DEPTH_CLEAR_VALUE:
  1659.      *params = (GLfloat) CC.Depth.Clear;
  1660.      break;
  1661.       case GL_DEPTH_FUNC:
  1662.      *params = (GLfloat) CC.Depth.Func;
  1663.      break;
  1664.       case GL_DEPTH_RANGE:
  1665.          params[0] = (GLfloat) CC.Viewport.Near;
  1666.          params[1] = (GLfloat) CC.Viewport.Far;
  1667.      break;
  1668.       case GL_DEPTH_SCALE:
  1669.      *params = (GLfloat) CC.Pixel.DepthScale;
  1670.      break;
  1671.       case GL_DEPTH_TEST:
  1672.      *params = (GLfloat) CC.Depth.Test;
  1673.      break;
  1674.       case GL_DEPTH_WRITEMASK:
  1675.      *params = (GLfloat) CC.Depth.Mask;
  1676.      break;
  1677.       case GL_DITHER:
  1678.      *params = (GLfloat) CC.Color.DitherFlag;
  1679.      break;
  1680.       case GL_DOUBLEBUFFER:
  1681.      *params = (GLfloat) CC.DBflag;
  1682.      break;
  1683.       case GL_DRAW_BUFFER:
  1684.      *params = (GLfloat) CC.Color.DrawBuffer;
  1685.      break;
  1686.       case GL_EDGE_FLAG:
  1687.      *params = (GLfloat) CC.Current.EdgeFlag;
  1688.      break;
  1689.       case GL_FOG:
  1690.      *params = (GLfloat) CC.Fog.Enabled;
  1691.      break;
  1692.       case GL_FOG_COLOR:
  1693.      params[0] = CC.Fog.Color[0];
  1694.      params[1] = CC.Fog.Color[1];
  1695.      params[2] = CC.Fog.Color[2];
  1696.      params[3] = CC.Fog.Color[3];
  1697.      break;
  1698.       case GL_FOG_DENSITY:
  1699.      *params = CC.Fog.Density;
  1700.      break;
  1701.       case GL_FOG_END:
  1702.      *params = CC.Fog.End;
  1703.      break;
  1704.       case GL_FOG_HINT:
  1705.      *params = (GLfloat) CC.Hint.Fog;
  1706.      break;
  1707.       case GL_FOG_INDEX:
  1708.      *params = CC.Fog.Index;
  1709.      break;
  1710.       case GL_FOG_MODE:
  1711.      *params = (GLfloat) CC.Fog.Mode;
  1712.      break;
  1713.       case GL_FOG_START:
  1714.      *params = CC.Fog.Start;
  1715.      break;
  1716.       case GL_FRONT_FACE:
  1717.      *params = (GLfloat) CC.Polygon.FrontFace;
  1718.      break;
  1719.       case GL_GREEN_BIAS:
  1720.          *params = (GLfloat) CC.Pixel.GreenBias;
  1721.          break;
  1722.       case GL_GREEN_BITS:
  1723.          *params = (GLfloat) bits( CC.GreenScale );
  1724.          break;
  1725.       case GL_GREEN_SCALE:
  1726.          *params = (GLfloat) CC.Pixel.GreenScale;
  1727.          break;
  1728.       case GL_INDEX_BITS:
  1729.      {
  1730.         GLuint width, height, depth;
  1731.         (*DD.buffer_size)( &width, &height, &depth );
  1732.         *params = (GLfloat) depth;
  1733.      }
  1734.      break;
  1735.       case GL_INDEX_CLEAR_VALUE:
  1736.          *params = (GLfloat) CC.Color.ClearIndex;
  1737.      break;
  1738.       case GL_INDEX_MODE:
  1739.      *params = (GLfloat) CC.RGBAflag;
  1740.      break;
  1741.       case GL_INDEX_OFFSET:
  1742.      *params = (GLfloat) CC.Pixel.IndexOffset;
  1743.      break;
  1744.       case GL_INDEX_SHIFT:
  1745.      *params = (GLfloat) CC.Pixel.IndexShift;
  1746.      break;
  1747.       case GL_INDEX_WRITEMASK:
  1748.      *params = (GLfloat) CC.Color.IndexMask;
  1749.      break;
  1750.       case GL_LIGHT0:
  1751.       case GL_LIGHT1:
  1752.       case GL_LIGHT2:
  1753.       case GL_LIGHT3:
  1754.       case GL_LIGHT4:
  1755.       case GL_LIGHT5:
  1756.       case GL_LIGHT6:
  1757.       case GL_LIGHT7:
  1758.      *params = (GLfloat) CC.Light.Light[pname-GL_LIGHT0].Enabled;
  1759.      break;
  1760.       case GL_LIGHTING:
  1761.      *params = (GLfloat) CC.Light.Enabled;
  1762.      break;
  1763.       case GL_LIGHT_MODEL_AMBIENT:
  1764.      params[0] = CC.Light.Model.Ambient[0];
  1765.      params[1] = CC.Light.Model.Ambient[1];
  1766.      params[2] = CC.Light.Model.Ambient[2];
  1767.      params[3] = CC.Light.Model.Ambient[3];
  1768.      break;
  1769.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  1770.      *params = (GLfloat) CC.Light.Model.LocalViewer;
  1771.      break;
  1772.       case GL_LIGHT_MODEL_TWO_SIDE:
  1773.      *params = (GLfloat) CC.Light.Model.TwoSide;
  1774.      break;
  1775.       case GL_LINE_SMOOTH:
  1776.      *params = (GLfloat) CC.Line.SmoothFlag;
  1777.      break;
  1778.       case GL_LINE_SMOOTH_HINT:
  1779.      *params = (GLfloat) CC.Hint.LineSmooth;
  1780.      break;
  1781.       case GL_LINE_STIPPLE:
  1782.      *params = (GLfloat) CC.Line.StippleFlag;
  1783.      break;
  1784.       case GL_LINE_STIPPLE_PATTERN:
  1785.          *params = (GLfloat) CC.Line.StipplePattern;
  1786.          break;
  1787.       case GL_LINE_STIPPLE_REPEAT:
  1788.          *params = (GLfloat) CC.Line.StippleFactor;
  1789.          break;
  1790.       case GL_LINE_WIDTH:
  1791.      *params = (GLfloat) CC.Line.Width;
  1792.      break;
  1793.       case GL_LINE_WIDTH_GRANULARITY:
  1794.      *params = (GLfloat) LINE_WIDTH_GRANULARITY;
  1795.      break;
  1796.       case GL_LINE_WIDTH_RANGE:
  1797.      params[0] = (GLfloat) MIN_LINE_WIDTH;
  1798.      params[1] = (GLfloat) MAX_LINE_WIDTH;
  1799.      break;
  1800.       case GL_LIST_BASE:
  1801.      *params = (GLfloat) CC.List.ListBase;
  1802.      break;
  1803.       case GL_LIST_INDEX:
  1804.      *params = (GLfloat) gl_list_index();
  1805.      break;
  1806.       case GL_LIST_MODE:
  1807.      *params = CC.ExecuteFlag ? (GLfloat) GL_COMPILE_AND_EXECUTE
  1808.                      : (GLfloat) GL_COMPILE;
  1809.      break;
  1810.       case GL_LOGIC_OP:
  1811.      *params = (GLfloat) CC.Color.LogicOpEnabled;
  1812.      break;
  1813.       case GL_LOGIC_OP_MODE:
  1814.          *params = (GLfloat) CC.Color.LogicOp;
  1815.      break;
  1816.       case GL_MAP1_COLOR_4:
  1817.      *params = (GLfloat) CC.Eval.Map1Color4;
  1818.      break;
  1819.       case GL_MAP1_GRID_DOMAIN:
  1820.      params[0] = CC.Eval.MapGrid1u1;
  1821.      params[1] = CC.Eval.MapGrid1u2;
  1822.      break;
  1823.       case GL_MAP1_GRID_SEGMENTS:
  1824.      *params = (GLfloat) CC.Eval.MapGrid1un;
  1825.      break;
  1826.       case GL_MAP1_INDEX:
  1827.      *params = (GLfloat) CC.Eval.Map1Index;
  1828.      break;
  1829.       case GL_MAP1_NORMAL:
  1830.      *params = (GLfloat) CC.Eval.Map1Normal;
  1831.      break;
  1832.       case GL_MAP1_TEXTURE_COORD_1:
  1833.      *params = (GLfloat) CC.Eval.Map1TextureCoord1;
  1834.      break;
  1835.       case GL_MAP1_TEXTURE_COORD_2:
  1836.      *params = (GLfloat) CC.Eval.Map1TextureCoord2;
  1837.      break;
  1838.       case GL_MAP1_TEXTURE_COORD_3:
  1839.      *params = (GLfloat) CC.Eval.Map1TextureCoord3;
  1840.      break;
  1841.       case GL_MAP1_TEXTURE_COORD_4:
  1842.      *params = (GLfloat) CC.Eval.Map1TextureCoord4;
  1843.      break;
  1844.       case GL_MAP1_VERTEX_3:
  1845.      *params = (GLfloat) CC.Eval.Map1Vertex3;
  1846.      break;
  1847.       case GL_MAP1_VERTEX_4:
  1848.      *params = (GLfloat) CC.Eval.Map1Vertex4;
  1849.      break;
  1850.       case GL_MAP2_COLOR_4:
  1851.      *params = (GLfloat) CC.Eval.Map2Color4;
  1852.      break;
  1853.       case GL_MAP2_GRID_DOMAIN:
  1854.      params[0] = CC.Eval.MapGrid2u1;
  1855.      params[1] = CC.Eval.MapGrid2u2;
  1856.      params[2] = CC.Eval.MapGrid2v1;
  1857.      params[3] = CC.Eval.MapGrid2v2;
  1858.      break;
  1859.       case GL_MAP2_GRID_SEGMENTS:
  1860.      params[0] = (GLfloat) CC.Eval.MapGrid2un;
  1861.      params[1] = (GLfloat) CC.Eval.MapGrid2vn;
  1862.      break;
  1863.       case GL_MAP2_INDEX:
  1864.      *params = (GLfloat) CC.Eval.Map2Index;
  1865.      break;
  1866.       case GL_MAP2_NORMAL:
  1867.      *params = (GLfloat) CC.Eval.Map2Normal;
  1868.      break;
  1869.       case GL_MAP2_TEXTURE_COORD_1:
  1870.      *params = CC.Eval.Map2TextureCoord1;
  1871.      break;
  1872.       case GL_MAP2_TEXTURE_COORD_2:
  1873.      *params = CC.Eval.Map2TextureCoord2;
  1874.      break;
  1875.       case GL_MAP2_TEXTURE_COORD_3:
  1876.      *params = CC.Eval.Map2TextureCoord3;
  1877.      break;
  1878.       case GL_MAP2_TEXTURE_COORD_4:
  1879.      *params = CC.Eval.Map2TextureCoord4;
  1880.      break;
  1881.       case GL_MAP2_VERTEX_3:
  1882.      *params = (GLfloat) CC.Eval.Map2Vertex3;
  1883.      break;
  1884.       case GL_MAP2_VERTEX_4:
  1885.      *params = (GLfloat) CC.Eval.Map2Vertex4;
  1886.      break;
  1887.       case GL_MAP_COLOR:
  1888.      *params = (GLfloat) CC.Pixel.MapColorFlag;
  1889.      break;
  1890.       case GL_MAP_STENCIL:
  1891.      *params = (GLfloat) CC.Pixel.MapStencilFlag;
  1892.      break;
  1893.       case GL_MATRIX_MODE:
  1894.      *params = (GLfloat) CC.Transform.MatrixMode;
  1895.      break;
  1896.       case GL_MAX_ATTRIB_STACK_DEPTH:
  1897.      *params = (GLfloat) MAX_ATTRIB_STACK_DEPTH;
  1898.      break;
  1899.       case GL_MAX_CLIP_PLANES:
  1900.      *params = (GLfloat) MAX_CLIP_PLANES;
  1901.      break;
  1902.       case GL_MAX_EVAL_ORDER:
  1903.      *params = (GLfloat) MAX_EVAL_ORDER;
  1904.      break;
  1905.       case GL_MAX_LIGHTS:
  1906.      *params = (GLfloat) MAX_LIGHTS;
  1907.      break;
  1908.       case GL_MAX_LIST_NESTING:
  1909.      *params = (GLfloat) MAX_LIST_NESTING;
  1910.      break;
  1911.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  1912.      *params = (GLfloat) MAX_MODELVIEW_STACK_DEPTH;
  1913.      break;
  1914.       case GL_MAX_NAME_STACK_DEPTH:
  1915.      *params = (GLfloat) MAX_NAME_STACK_DEPTH;
  1916.      break;
  1917.       case GL_MAX_PIXEL_MAP_TABLE:
  1918.      *params = (GLfloat) MAX_PIXEL_MAP_TABLE;
  1919.      break;
  1920.       case GL_MAX_PROJECTION_STACK_DEPTH:
  1921.      *params = (GLfloat) MAX_PROJECTION_STACK_DEPTH;
  1922.      break;
  1923.       case GL_MAX_TEXTURE_SIZE:
  1924.      *params = (GLfloat) MAX_TEXTURE_SIZE;
  1925.      break;
  1926.       case GL_MAX_TEXTURE_STACK_DEPTH:
  1927.      *params = (GLfloat) MAX_TEXTURE_STACK_DEPTH;
  1928.      break;
  1929.       case GL_MAX_VIEWPORT_DIMS:
  1930.          params[0] = (GLfloat) MAX_WIDTH;
  1931.          params[1] = (GLfloat) MAX_HEIGHT;
  1932.          break;
  1933.       case GL_MODELVIEW_MATRIX:
  1934.      for (i=0;i<16;i++) {
  1935.         params[i] = CC.ModelViewMatrix[i];
  1936.      }
  1937.      break;
  1938.       case GL_MODELVIEW_STACK_DEPTH:
  1939.      *params = (GLfloat) CC.ModelViewStackDepth;
  1940.      break;
  1941.       case GL_NAME_STACK_DEPTH:
  1942.      *params = (GLfloat) CC.NameStackDepth;
  1943.      break;
  1944.       case GL_NORMALIZE:
  1945.      *params = (GLfloat) CC.Transform.Normalize;
  1946.      break;
  1947.       case GL_PACK_ALIGNMENT:
  1948.      *params = (GLfloat) CC.PackAlignment;
  1949.      break;
  1950.       case GL_PACK_LSB_FIRST:
  1951.      *params = (GLfloat) CC.PackLSBFirst;
  1952.      break;
  1953.       case GL_PACK_ROW_LENGTH:
  1954.      *params = (GLfloat) CC.PackRowLength;
  1955.      break;
  1956.       case GL_PACK_SKIP_PIXELS:
  1957.      *params = (GLfloat) CC.PackSkipPixels;
  1958.      break;
  1959.       case GL_PACK_SKIP_ROWS:
  1960.      *params = (GLfloat) CC.PackSkipRows;
  1961.      break;
  1962.       case GL_PACK_SWAP_BYTES:
  1963.      *params = (GLfloat) CC.PackSwapBytes;
  1964.      break;
  1965.       case GL_PERSPECTIVE_CORRECTION_HINT:
  1966.      *params = (GLfloat) CC.Hint.PerspectiveCorrection;
  1967.      break;
  1968.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  1969.      *params = (GLfloat) CC.Pixel.MapAtoAsize;
  1970.      break;
  1971.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  1972.      *params = (GLfloat) CC.Pixel.MapBtoBsize;
  1973.      break;
  1974.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  1975.      *params = (GLfloat) CC.Pixel.MapGtoGsize;
  1976.      break;
  1977.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  1978.      *params = (GLfloat) CC.Pixel.MapItoAsize;
  1979.      break;
  1980.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  1981.      *params = (GLfloat) CC.Pixel.MapItoBsize;
  1982.      break;
  1983.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  1984.      *params = (GLfloat) CC.Pixel.MapItoGsize;
  1985.      break;
  1986.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  1987.      *params = (GLfloat) CC.Pixel.MapItoIsize;
  1988.      break;
  1989.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  1990.      *params = (GLfloat) CC.Pixel.MapItoRsize;
  1991.      break;
  1992.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  1993.      *params = (GLfloat) CC.Pixel.MapRtoRsize;
  1994.      break;
  1995.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  1996.      *params = (GLfloat) CC.Pixel.MapStoSsize;
  1997.      break;
  1998.       case GL_POINT_SIZE:
  1999.          *params = (GLfloat) CC.Point.Size;
  2000.          break;
  2001.       case GL_POINT_SIZE_GRANULARITY:
  2002.      *params = (GLfloat) POINT_SIZE_GRANULARITY;
  2003.      break;
  2004.       case GL_POINT_SIZE_RANGE:
  2005.      params[0] = (GLfloat) MIN_POINT_SIZE;
  2006.      params[1] = (GLfloat) MAX_POINT_SIZE;
  2007.      break;
  2008.       case GL_POINT_SMOOTH:
  2009.      *params = (GLfloat) CC.Point.SmoothFlag;
  2010.      break;
  2011.       case GL_POINT_SMOOTH_HINT:
  2012.      *params = (GLfloat) CC.Hint.PointSmooth;
  2013.      break;
  2014.       case GL_POLYGON_MODE:
  2015.      params[0] = (GLfloat) CC.Polygon.FrontMode;
  2016.      params[1] = (GLfloat) CC.Polygon.BackMode;
  2017.      break;
  2018.       case GL_POLYGON_OFFSET_BIAS_EXT:
  2019.          *params = CC.Polygon.OffsetBias;
  2020.          break;
  2021.       case GL_POLYGON_OFFSET_FACTOR_EXT:
  2022.          *params = CC.Polygon.OffsetFactor;
  2023.          break;
  2024.       case GL_POLYGON_SMOOTH:
  2025.      *params = (GLfloat) CC.Polygon.SmoothFlag;
  2026.      break;
  2027.       case GL_POLYGON_SMOOTH_HINT:
  2028.      *params = (GLfloat) CC.Hint.PolygonSmooth;
  2029.      break;
  2030.       case GL_POLYGON_STIPPLE:
  2031.      for (i=0;i<32;i++) {        /* RIGHT? */
  2032.         params[i] = (GLfloat) CC.PolygonStipple[i];
  2033.      }
  2034.      break;
  2035.       case GL_PROJECTION_MATRIX:
  2036.      for (i=0;i<16;i++) {
  2037.         params[i] = CC.ProjectionMatrix[i];
  2038.      }
  2039.      break;
  2040.       case GL_PROJECTION_STACK_DEPTH:
  2041.      *params = (GLfloat) CC.ProjectionStackDepth;
  2042.      break;
  2043.       case GL_READ_BUFFER:
  2044.      *params = (GLfloat) CC.Pixel.ReadBuffer;
  2045.      break;
  2046.       case GL_RED_BIAS:
  2047.          *params = CC.Pixel.RedBias;
  2048.          break;
  2049.       case GL_RED_BITS:
  2050.          *params = (GLfloat) bits( CC.RedScale );
  2051.          break;
  2052.       case GL_RED_SCALE:
  2053.          *params = CC.Pixel.RedScale;
  2054.          break;
  2055.       case GL_RENDER_MODE:
  2056.      *params = (GLfloat) CC.RenderMode;
  2057.      break;
  2058.       case GL_RGBA_MODE:
  2059.      *params = (GLfloat) CC.RGBAflag;
  2060.      break;
  2061.       case GL_SCISSOR_BOX:
  2062.      params[0] = (GLfloat) CC.Scissor.X;
  2063.      params[1] = (GLfloat) CC.Scissor.Y;
  2064.      params[2] = (GLfloat) CC.Scissor.Width;
  2065.      params[3] = (GLfloat) CC.Scissor.Height;
  2066.      break;
  2067.       case GL_SCISSOR_TEST:
  2068.      *params = (GLfloat) CC.Scissor.Enabled;
  2069.      break;
  2070.       case GL_SHADE_MODEL:
  2071.      *params = (GLfloat) CC.Light.ShadeModel;
  2072.      break;
  2073.       case GL_STENCIL_BITS:
  2074.          *params = (GLfloat) STENCIL_BITS;
  2075.          break;
  2076.       case GL_STENCIL_CLEAR_VALUE:
  2077.      *params = (GLfloat) CC.Stencil.Clear;
  2078.      break;
  2079.       case GL_STENCIL_FAIL:
  2080.      *params = (GLfloat) CC.Stencil.FailFunc;
  2081.      break;
  2082.       case GL_STENCIL_FUNC:
  2083.      *params = (GLfloat) CC.Stencil.Function;
  2084.      break;
  2085.       case GL_STENCIL_PASS_DEPTH_FAIL:
  2086.      *params = (GLfloat) CC.Stencil.ZFailFunc;
  2087.      break;
  2088.       case GL_STENCIL_PASS_DEPTH_PASS:
  2089.      *params = (GLfloat) CC.Stencil.ZPassFunc;
  2090.      break;
  2091.       case GL_STENCIL_REF:
  2092.      *params = (GLfloat) CC.Stencil.Ref;
  2093.      break;
  2094.       case GL_STENCIL_TEST:
  2095.      *params = (GLfloat) CC.Stencil.Enabled;
  2096.      break;
  2097.       case GL_STENCIL_VALUE_MASK:
  2098.      *params = (GLfloat) CC.Stencil.ValueMask;
  2099.      break;
  2100.       case GL_STENCIL_WRITEMASK:
  2101.      *params = (GLfloat) CC.Stencil.WriteMask;
  2102.      break;
  2103.       case GL_STEREO:
  2104.      *params = 0.0F;  /* TODO */
  2105.      break;
  2106.       case GL_SUBPIXEL_BITS:
  2107.      *params = 0.0F;  /* TODO */
  2108.      break;
  2109.       case GL_TEXTURE_1D:
  2110.      *params = (CC.Texture.Enabled & 1) ? 1.0 : 0.0;
  2111.      break;
  2112.       case GL_TEXTURE_2D:
  2113.      *params = (CC.Texture.Enabled & 2) ? 1.0 : 0.0;
  2114.      break;
  2115.       case GL_TEXTURE_ENV_COLOR:
  2116.      params[0] = CC.Texture.EnvColor[0];
  2117.      params[1] = CC.Texture.EnvColor[1];
  2118.      params[2] = CC.Texture.EnvColor[2];
  2119.      params[3] = CC.Texture.EnvColor[3];
  2120.      break;
  2121.       case GL_TEXTURE_ENV_MODE:
  2122.      *params = (GLfloat) CC.Texture.EnvMode;
  2123.      break;
  2124.       case GL_TEXTURE_GEN_S:
  2125.      *params = (CC.Texture.TexGenEnabled & S_BIT) ? 1.0 : 0.0;
  2126.      break;
  2127.       case GL_TEXTURE_GEN_T:
  2128.      *params = (CC.Texture.TexGenEnabled & T_BIT) ? 1.0 : 0.0;
  2129.      break;
  2130.       case GL_TEXTURE_GEN_R:
  2131.      *params = (CC.Texture.TexGenEnabled & R_BIT) ? 1.0 : 0.0;
  2132.      break;
  2133.       case GL_TEXTURE_GEN_Q:
  2134.      *params = (CC.Texture.TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
  2135.      break;
  2136.       case GL_TEXTURE_MATRIX:
  2137.          for (i=0;i<16;i++) {
  2138.         params[i] = CC.TextureMatrix[i];
  2139.      }
  2140.      break;
  2141.       case GL_TEXTURE_STACK_DEPTH:
  2142.      *params = (GLfloat) CC.TextureStackDepth;
  2143.      break;
  2144.       case GL_UNPACK_ALIGNMENT:
  2145.      *params = (GLfloat) CC.UnpackAlignment;
  2146.      break;
  2147.       case GL_UNPACK_LSB_FIRST:
  2148.      *params = (GLfloat) CC.UnpackLSBFirst;
  2149.      break;
  2150.       case GL_UNPACK_ROW_LENGTH:
  2151.      *params = (GLfloat) CC.UnpackRowLength;
  2152.      break;
  2153.       case GL_UNPACK_SKIP_PIXELS:
  2154.      *params = (GLfloat) CC.UnpackSkipPixels;
  2155.      break;
  2156.       case GL_UNPACK_SKIP_ROWS:
  2157.      *params = (GLfloat) CC.UnpackSkipRows;
  2158.      break;
  2159.       case GL_UNPACK_SWAP_BYTES:
  2160.      *params = (GLfloat) CC.UnpackSwapBytes;
  2161.      break;
  2162.       case GL_VIEWPORT:
  2163.      params[0] = (GLfloat) CC.Viewport.X;
  2164.      params[1] = (GLfloat) CC.Viewport.Y;
  2165.      params[2] = (GLfloat) CC.Viewport.Width;
  2166.      params[3] = (GLfloat) CC.Viewport.Height;
  2167.      break;
  2168.       case GL_ZOOM_X:
  2169.      *params = (GLfloat) CC.Pixel.ZoomX;
  2170.      break;
  2171.       case GL_ZOOM_Y:
  2172.      *params = (GLfloat) CC.Pixel.ZoomY;
  2173.      break;
  2174.       default:
  2175.          gl_error( GL_INVALID_ENUM, "glGetFloatv" );
  2176.    }
  2177. }
  2178.  
  2179.  
  2180.  
  2181.  
  2182. void glGetIntegerv( GLenum pname, GLint *params )
  2183. {
  2184.    GLuint i;
  2185.  
  2186.    if (INSIDE_BEGIN_END) {
  2187.       gl_error( GL_INVALID_OPERATION, "glGetIntegerv" );
  2188.       return;
  2189.    }
  2190.    switch (pname) {
  2191.       case GL_ACCUM_RED_BITS:
  2192.       case GL_ACCUM_GREEN_BITS:
  2193.       case GL_ACCUM_BLUE_BITS:
  2194.       case GL_ACCUM_ALPHA_BITS:
  2195.          *params = (GLint) (sizeof(ACC_TYPE)*8);
  2196.          break;
  2197.       case GL_ACCUM_CLEAR_VALUE:
  2198.          params[0] = FLOAT_TO_INT( CC.Accum.ClearColor[0] );
  2199.          params[1] = FLOAT_TO_INT( CC.Accum.ClearColor[1] );
  2200.          params[2] = FLOAT_TO_INT( CC.Accum.ClearColor[2] );
  2201.          params[3] = FLOAT_TO_INT( CC.Accum.ClearColor[3] );
  2202.          break;
  2203.       case GL_ALPHA_BIAS:
  2204.          *params = (GLint) CC.Pixel.AlphaBias;
  2205.          break;
  2206.       case GL_ALPHA_BITS:
  2207.          *params = (GLint) bits( CC.AlphaScale );
  2208.          break;
  2209.       case GL_ALPHA_SCALE:
  2210.          *params = (GLint) CC.Pixel.AlphaScale;
  2211.          break;
  2212.       case GL_ALPHA_TEST:
  2213.          *params = (GLint) CC.Color.AlphaEnabled;
  2214.          break;
  2215.       case GL_ALPHA_TEST_REF:
  2216.          *params = FLOAT_TO_INT( CC.Color.AlphaRef );
  2217.          break;
  2218.       case GL_ALPHA_TEST_FUNC:
  2219.          *params = (GLint) CC.Color.AlphaFunc;
  2220.          break;
  2221.       case GL_ATTRIB_STACK_DEPTH:
  2222.          *params = (GLint) CC.AttribStackDepth;
  2223.          break;
  2224.       case GL_AUTO_NORMAL:
  2225.          *params = (GLint) CC.Eval.AutoNormal;
  2226.          break;
  2227.       case GL_AUX_BUFFERS:
  2228.          *params = (GLint) NUM_AUX_BUFFERS;
  2229.          break;
  2230.       case GL_BLEND:
  2231.          *params = (GLint) CC.Color.BlendEnabled;
  2232.          break;
  2233.       case GL_BLEND_DST:
  2234.          *params = (GLint) CC.Color.BlendDst;
  2235.          break;
  2236.       case GL_BLEND_SRC:
  2237.          *params = (GLint) CC.Color.BlendSrc;
  2238.          break;
  2239.       case GL_BLEND_EQUATION_EXT:
  2240.      *params = (GLint) CC.Color.BlendEquation;
  2241.      break;
  2242.       case GL_BLEND_COLOR_EXT:
  2243.      params[0] = FLOAT_TO_INT( CC.Color.BlendColor[0] );
  2244.      params[1] = FLOAT_TO_INT( CC.Color.BlendColor[1] );
  2245.      params[2] = FLOAT_TO_INT( CC.Color.BlendColor[2] );
  2246.      params[3] = FLOAT_TO_INT( CC.Color.BlendColor[3] );
  2247.      break;
  2248.       case GL_BLUE_BIAS:
  2249.          *params = (GLint) CC.Pixel.BlueBias;
  2250.          break;
  2251.       case GL_BLUE_BITS:
  2252.          *params = (GLint) bits( CC.BlueScale );
  2253.          break;
  2254.       case GL_BLUE_SCALE:
  2255.          *params = (GLint) CC.Pixel.BlueScale;
  2256.          break;
  2257.       case GL_CLIP_PLANE0:
  2258.       case GL_CLIP_PLANE1:
  2259.       case GL_CLIP_PLANE2:
  2260.       case GL_CLIP_PLANE3:
  2261.       case GL_CLIP_PLANE4:
  2262.       case GL_CLIP_PLANE5:
  2263.          i = (GLint) (pname - GL_CLIP_PLANE0);
  2264.          *params = (GLint) CC.Transform.ClipEnabled[i];
  2265.          break;
  2266.       case GL_COLOR_CLEAR_VALUE:
  2267.          params[0] = FLOAT_TO_INT( CC.Color.ClearColor[0] );
  2268.          params[1] = FLOAT_TO_INT( CC.Color.ClearColor[1] );
  2269.          params[2] = FLOAT_TO_INT( CC.Color.ClearColor[2] );
  2270.          params[3] = FLOAT_TO_INT( CC.Color.ClearColor[3] );
  2271.          break;
  2272.       case GL_COLOR_MATERIAL:
  2273.          *params = (GLint) CC.Light.ColorMaterialEnabled;
  2274.          break;
  2275.       case GL_COLOR_MATERIAL_FACE:
  2276.          *params = (GLint) CC.Light.ColorMaterialFace;
  2277.          break;
  2278.       case GL_COLOR_MATERIAL_PARAMETER:
  2279.          *params = (GLint) CC.Light.ColorMaterialMode;
  2280.          break;
  2281.       case GL_COLOR_WRITEMASK:
  2282.          params[0] = (CC.Color.ColorMask & 8) ? 1 : 0;
  2283.          params[1] = (CC.Color.ColorMask & 4) ? 1 : 0;
  2284.          params[2] = (CC.Color.ColorMask & 2) ? 1 : 0;
  2285.          params[3] = (CC.Color.ColorMask & 1) ? 1 : 0;
  2286.          break;
  2287.       case GL_CULL_FACE:
  2288.          *params = (GLint) CC.Polygon.CullFlag;
  2289.          break;
  2290.       case GL_CULL_FACE_MODE:
  2291.          *params = (GLint) CC.Polygon.CullFaceMode;
  2292.          break;
  2293.       case GL_CURRENT_COLOR:
  2294.          params[0] = FLOAT_TO_INT( CC.Current.Color[0] );
  2295.          params[1] = FLOAT_TO_INT( CC.Current.Color[1] );
  2296.          params[2] = FLOAT_TO_INT( CC.Current.Color[2] );
  2297.          params[3] = FLOAT_TO_INT( CC.Current.Color[3] );
  2298.          break;
  2299.       case GL_CURRENT_INDEX:
  2300.          *params = (GLint) CC.Current.Index;
  2301.          break;
  2302.       case GL_CURRENT_NORMAL:
  2303.          params[0] = FLOAT_TO_INT( CC.Current.Normal[0] );
  2304.          params[1] = FLOAT_TO_INT( CC.Current.Normal[1] );
  2305.          params[2] = FLOAT_TO_INT( CC.Current.Normal[2] );
  2306.          break;
  2307.       case GL_CURRENT_RASTER_COLOR:
  2308.      params[0] = FLOAT_TO_INT( CC.Current.RasterColor[0] );
  2309.      params[1] = FLOAT_TO_INT( CC.Current.RasterColor[1] );
  2310.      params[2] = FLOAT_TO_INT( CC.Current.RasterColor[2] );
  2311.      params[3] = FLOAT_TO_INT( CC.Current.RasterColor[3] );
  2312.      break;
  2313.       case GL_CURRENT_RASTER_DISTANCE:
  2314.      params[0] = (GLint) CC.Current.RasterDistance;
  2315.      break;
  2316.       case GL_CURRENT_RASTER_INDEX:
  2317.      *params = (GLint) CC.Current.RasterIndex;
  2318.      break;
  2319.       case GL_CURRENT_RASTER_POSITION:
  2320.      params[0] = (GLint) CC.Current.RasterPos[0];
  2321.      params[1] = (GLint) CC.Current.RasterPos[1];
  2322.      params[2] = (GLint) CC.Current.RasterPos[2];
  2323.      params[3] = (GLint) CC.Current.RasterPos[3];
  2324.      break;
  2325.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  2326.      params[0] = (GLint) CC.Current.RasterTexCoord[0];
  2327.      params[1] = (GLint) CC.Current.RasterTexCoord[1];
  2328.      params[2] = (GLint) CC.Current.RasterTexCoord[2];
  2329.      params[3] = (GLint) CC.Current.RasterTexCoord[3];
  2330.      break;
  2331.       case GL_CURRENT_RASTER_POSITION_VALID:
  2332.      *params = (GLint) CC.Current.RasterPosValid;
  2333.      break;
  2334.       case GL_CURRENT_TEXTURE_COORDS:
  2335.          params[0] = (GLint) CC.Current.TexCoord[0];
  2336.          params[1] = (GLint) CC.Current.TexCoord[1];
  2337.          params[2] = (GLint) CC.Current.TexCoord[2];
  2338.          params[3] = (GLint) CC.Current.TexCoord[3];
  2339.      break;
  2340.       case GL_DEPTH_BIAS:
  2341.          *params = (GLint) CC.Pixel.DepthBias;
  2342.      break;
  2343.       case GL_DEPTH_BITS:
  2344.      *params = 8*sizeof(GLint);
  2345.      break;
  2346.       case GL_DEPTH_CLEAR_VALUE:
  2347.          *params = (GLint) CC.Depth.Clear;
  2348.      break;
  2349.       case GL_DEPTH_FUNC:
  2350.          *params = (GLint) CC.Depth.Func;
  2351.      break;
  2352.       case GL_DEPTH_RANGE:
  2353.          params[0] = (GLint) CC.Viewport.Near;
  2354.          params[1] = (GLint) CC.Viewport.Far;
  2355.      break;
  2356.       case GL_DEPTH_SCALE:
  2357.          *params = (GLint) CC.Pixel.DepthScale;
  2358.      break;
  2359.       case GL_DEPTH_TEST:
  2360.          *params = (GLint) CC.Depth.Test;
  2361.      break;
  2362.       case GL_DEPTH_WRITEMASK:
  2363.      *params = (GLint) CC.Depth.Mask;
  2364.      break;
  2365.       case GL_DITHER:
  2366.      *params = (GLint) CC.Color.DitherFlag;
  2367.      break;
  2368.       case GL_DOUBLEBUFFER:
  2369.      *params = (GLint) CC.DBflag;
  2370.      break;
  2371.       case GL_DRAW_BUFFER:
  2372.      *params = (GLint) CC.Color.DrawBuffer;
  2373.      break;
  2374.       case GL_EDGE_FLAG:
  2375.      *params = (GLint) CC.Current.EdgeFlag;
  2376.      break;
  2377.       case GL_FOG:
  2378.      *params = (GLint) CC.Fog.Enabled;
  2379.      break;
  2380.       case GL_FOG_COLOR:
  2381.      params[0] = FLOAT_TO_INT( CC.Fog.Color[0] );
  2382.      params[1] = FLOAT_TO_INT( CC.Fog.Color[1] );
  2383.      params[2] = FLOAT_TO_INT( CC.Fog.Color[2] );
  2384.      params[3] = FLOAT_TO_INT( CC.Fog.Color[3] );
  2385.      break;
  2386.       case GL_FOG_DENSITY:
  2387.      *params = (GLint) CC.Fog.Density;
  2388.      break;
  2389.       case GL_FOG_END:
  2390.      *params = (GLint) CC.Fog.End;
  2391.      break;
  2392.       case GL_FOG_HINT:
  2393.      *params = (GLint) CC.Hint.Fog;
  2394.      break;
  2395.       case GL_FOG_INDEX:
  2396.      *params = (GLint) CC.Fog.Index;
  2397.      break;
  2398.       case GL_FOG_MODE:
  2399.      *params = (GLint) CC.Fog.Mode;
  2400.      break;
  2401.       case GL_FOG_START:
  2402.      *params = (GLint) CC.Fog.Start;
  2403.      break;
  2404.       case GL_FRONT_FACE:
  2405.      *params = (GLint) CC.Polygon.FrontFace;
  2406.      break;
  2407.       case GL_GREEN_BIAS:
  2408.          *params = (GLint) CC.Pixel.GreenBias;
  2409.          break;
  2410.       case GL_GREEN_BITS:
  2411.          *params = (GLint) bits( CC.GreenScale );
  2412.          break;
  2413.       case GL_GREEN_SCALE:
  2414.          *params = (GLint) CC.Pixel.GreenScale;
  2415.          break;
  2416.       case GL_INDEX_BITS:
  2417.      {
  2418.         GLuint width, height, depth;
  2419.         (*DD.buffer_size)( &width, &height, &depth );
  2420.         *params = (GLint) depth;
  2421.      }
  2422.          break;
  2423.       case GL_INDEX_CLEAR_VALUE:
  2424.          *params = (GLint) CC.Color.ClearIndex;
  2425.          break;
  2426.       case GL_INDEX_MODE:
  2427.      *params = (GLint) CC.RGBAflag;
  2428.      break;
  2429.       case GL_INDEX_OFFSET:
  2430.      *params = CC.Pixel.IndexOffset;
  2431.      break;
  2432.       case GL_INDEX_SHIFT:
  2433.      *params = CC.Pixel.IndexShift;
  2434.      break;
  2435.       case GL_INDEX_WRITEMASK:
  2436.      *params = (GLint) CC.Color.IndexMask;
  2437.      break;
  2438.       case GL_LIGHT0:
  2439.       case GL_LIGHT1:
  2440.       case GL_LIGHT2:
  2441.       case GL_LIGHT3:
  2442.       case GL_LIGHT4:
  2443.       case GL_LIGHT5:
  2444.       case GL_LIGHT6:
  2445.       case GL_LIGHT7:
  2446.      *params = (GLint) CC.Light.Light[pname-GL_LIGHT0].Enabled;
  2447.      break;
  2448.       case GL_LIGHTING:
  2449.      *params = (GLint) CC.Light.Enabled;
  2450.      break;
  2451.       case GL_LIGHT_MODEL_AMBIENT:
  2452.      params[0] = FLOAT_TO_INT( CC.Light.Model.Ambient[0] );
  2453.      params[1] = FLOAT_TO_INT( CC.Light.Model.Ambient[1] );
  2454.      params[2] = FLOAT_TO_INT( CC.Light.Model.Ambient[2] );
  2455.      params[3] = FLOAT_TO_INT( CC.Light.Model.Ambient[3] );
  2456.      break;
  2457.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  2458.      *params = (GLint) CC.Light.Model.LocalViewer;
  2459.      break;
  2460.       case GL_LIGHT_MODEL_TWO_SIDE:
  2461.      *params = (GLint) CC.Light.Model.TwoSide;
  2462.      break;
  2463.       case GL_LINE_SMOOTH:
  2464.      *params = (GLint) CC.Line.SmoothFlag;
  2465.      break;
  2466.       case GL_LINE_SMOOTH_HINT:
  2467.      *params = (GLint) CC.Hint.LineSmooth;
  2468.      break;
  2469.       case GL_LINE_STIPPLE:
  2470.      *params = (GLint) CC.Line.StippleFlag;
  2471.      break;
  2472.       case GL_LINE_STIPPLE_PATTERN:
  2473.          *params = (GLint) CC.Line.StipplePattern;
  2474.          break;
  2475.       case GL_LINE_STIPPLE_REPEAT:
  2476.          *params = (GLint) CC.Line.StippleFactor;
  2477.          break;
  2478.       case GL_LINE_WIDTH:
  2479.      *params = (GLint) CC.Line.Width;
  2480.      break;
  2481.       case GL_LINE_WIDTH_GRANULARITY:
  2482.      *params = (GLint) LINE_WIDTH_GRANULARITY;
  2483.      break;
  2484.       case GL_LINE_WIDTH_RANGE:
  2485.      params[0] = (GLint) MIN_LINE_WIDTH;
  2486.      params[1] = (GLint) MAX_LINE_WIDTH;
  2487.      break;
  2488.       case GL_LIST_BASE:
  2489.      *params = (GLint) CC.List.ListBase;
  2490.      break;
  2491.       case GL_LIST_INDEX:
  2492.      *params = (GLint) gl_list_index();
  2493.      break;
  2494.       case GL_LIST_MODE:
  2495.      *params = CC.ExecuteFlag ? (GLint) GL_COMPILE_AND_EXECUTE
  2496.                      : (GLint) GL_COMPILE;
  2497.      break;
  2498.       case GL_LOGIC_OP:
  2499.      *params = (GLint) CC.Color.LogicOpEnabled;
  2500.      break;
  2501.       case GL_LOGIC_OP_MODE:
  2502.          *params = (GLint) CC.Color.LogicOp;
  2503.          break;
  2504.       case GL_MAP1_COLOR_4:
  2505.      *params = (GLint) CC.Eval.Map1Color4;
  2506.      break;
  2507.       case GL_MAP1_GRID_DOMAIN:
  2508.      params[0] = (GLint) CC.Eval.MapGrid1u1;
  2509.      params[1] = (GLint) CC.Eval.MapGrid1u2;
  2510.      break;
  2511.       case GL_MAP1_GRID_SEGMENTS:
  2512.      *params = (GLint) CC.Eval.MapGrid1un;
  2513.      break;
  2514.       case GL_MAP1_INDEX:
  2515.      *params = (GLint) CC.Eval.Map1Index;
  2516.      break;
  2517.       case GL_MAP1_NORMAL:
  2518.      *params = (GLint) CC.Eval.Map1Normal;
  2519.      break;
  2520.       case GL_MAP1_TEXTURE_COORD_1:
  2521.      *params = (GLint) CC.Eval.Map1TextureCoord1;
  2522.      break;
  2523.       case GL_MAP1_TEXTURE_COORD_2:
  2524.      *params = (GLint) CC.Eval.Map1TextureCoord2;
  2525.      break;
  2526.       case GL_MAP1_TEXTURE_COORD_3:
  2527.      *params = (GLint) CC.Eval.Map1TextureCoord3;
  2528.      break;
  2529.       case GL_MAP1_TEXTURE_COORD_4:
  2530.      *params = (GLint) CC.Eval.Map1TextureCoord4;
  2531.      break;
  2532.       case GL_MAP1_VERTEX_3:
  2533.      *params = (GLint) CC.Eval.Map1Vertex3;
  2534.      break;
  2535.       case GL_MAP1_VERTEX_4:
  2536.      *params = (GLint) CC.Eval.Map1Vertex4;
  2537.      break;
  2538.       case GL_MAP2_COLOR_4:
  2539.      *params = (GLint) CC.Eval.Map2Color4;
  2540.      break;
  2541.       case GL_MAP2_GRID_DOMAIN:
  2542.      params[0] = (GLint) CC.Eval.MapGrid2u1;
  2543.      params[1] = (GLint) CC.Eval.MapGrid2u2;
  2544.      params[2] = (GLint) CC.Eval.MapGrid2v1;
  2545.      params[3] = (GLint) CC.Eval.MapGrid2v2;
  2546.      break;
  2547.       case GL_MAP2_GRID_SEGMENTS:
  2548.      params[0] = (GLint) CC.Eval.MapGrid2un;
  2549.      params[1] = (GLint) CC.Eval.MapGrid2vn;
  2550.      break;
  2551.       case GL_MAP2_INDEX:
  2552.      *params = (GLint) CC.Eval.Map2Index;
  2553.      break;
  2554.       case GL_MAP2_NORMAL:
  2555.      *params = (GLint) CC.Eval.Map2Normal;
  2556.      break;
  2557.       case GL_MAP2_TEXTURE_COORD_1:
  2558.      *params = (GLint) CC.Eval.Map2TextureCoord1;
  2559.      break;
  2560.       case GL_MAP2_TEXTURE_COORD_2:
  2561.      *params = (GLint) CC.Eval.Map2TextureCoord2;
  2562.      break;
  2563.       case GL_MAP2_TEXTURE_COORD_3:
  2564.      *params = (GLint) CC.Eval.Map2TextureCoord3;
  2565.      break;
  2566.       case GL_MAP2_TEXTURE_COORD_4:
  2567.      *params = (GLint) CC.Eval.Map2TextureCoord4;
  2568.      break;
  2569.       case GL_MAP2_VERTEX_3:
  2570.      *params = (GLint) CC.Eval.Map2Vertex3;
  2571.      break;
  2572.       case GL_MAP2_VERTEX_4:
  2573.      *params = (GLint) CC.Eval.Map2Vertex4;
  2574.      break;
  2575.       case GL_MAP_COLOR:
  2576.      *params = (GLint) CC.Pixel.MapColorFlag;
  2577.      break;
  2578.       case GL_MAP_STENCIL:
  2579.      *params = (GLint) CC.Pixel.MapStencilFlag;
  2580.      break;
  2581.       case GL_MATRIX_MODE:
  2582.      *params = (GLint) CC.Transform.MatrixMode;
  2583.      break;
  2584.       case GL_MAX_ATTRIB_STACK_DEPTH:
  2585.          *params = (GLint) MAX_ATTRIB_STACK_DEPTH;
  2586.          break;
  2587.       case GL_MAX_CLIP_PLANES:
  2588.          *params = (GLint) MAX_CLIP_PLANES;
  2589.          break;
  2590.       case GL_MAX_EVAL_ORDER:
  2591.      *params = (GLint) MAX_EVAL_ORDER;
  2592.      break;
  2593.       case GL_MAX_LIGHTS:
  2594.          *params = (GLint) MAX_LIGHTS;
  2595.          break;
  2596.       case GL_MAX_LIST_NESTING:
  2597.          *params = (GLint) MAX_LIST_NESTING;
  2598.          break;
  2599.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  2600.          *params = (GLint) MAX_MODELVIEW_STACK_DEPTH;
  2601.          break;
  2602.       case GL_MAX_NAME_STACK_DEPTH:
  2603.      *params = (GLint) MAX_NAME_STACK_DEPTH;
  2604.      break;
  2605.       case GL_MAX_PIXEL_MAP_TABLE:
  2606.      *params = (GLint) MAX_PIXEL_MAP_TABLE;
  2607.      break;
  2608.       case GL_MAX_PROJECTION_STACK_DEPTH:
  2609.          *params = (GLint) MAX_PROJECTION_STACK_DEPTH;
  2610.          break;
  2611.       case GL_MAX_TEXTURE_SIZE:
  2612.      *params = (GLint) MAX_TEXTURE_SIZE;
  2613.      break;
  2614.       case GL_MAX_TEXTURE_STACK_DEPTH:
  2615.      *params = (GLint) MAX_TEXTURE_STACK_DEPTH;
  2616.      break;
  2617.       case GL_MAX_VIEWPORT_DIMS:
  2618.          params[0] = (GLint) MAX_WIDTH;
  2619.          params[1] = (GLint) MAX_HEIGHT;
  2620.          break;
  2621.       case GL_MODELVIEW_MATRIX:
  2622.      for (i=0;i<16;i++) {
  2623.         params[i] = (GLint) CC.ModelViewMatrix[i];
  2624.      }
  2625.      break;
  2626.       case GL_MODELVIEW_STACK_DEPTH:
  2627.      *params = (GLint) CC.ModelViewStackDepth;
  2628.      break;
  2629.       case GL_NAME_STACK_DEPTH:
  2630.      *params = (GLint) CC.NameStackDepth;
  2631.      break;
  2632.       case GL_NORMALIZE:
  2633.      *params = (GLint) CC.Transform.Normalize;
  2634.      break;
  2635.       case GL_PACK_ALIGNMENT:
  2636.      *params = CC.PackAlignment;
  2637.      break;
  2638.       case GL_PACK_LSB_FIRST:
  2639.      *params = (GLint) CC.PackLSBFirst;
  2640.      break;
  2641.       case GL_PACK_ROW_LENGTH:
  2642.      *params = CC.PackRowLength;
  2643.      break;
  2644.       case GL_PACK_SKIP_PIXELS:
  2645.      *params = CC.PackSkipPixels;
  2646.      break;
  2647.       case GL_PACK_SKIP_ROWS:
  2648.      *params = CC.PackSkipRows;
  2649.      break;
  2650.       case GL_PACK_SWAP_BYTES:
  2651.      *params = (GLint) CC.PackSwapBytes;
  2652.      break;
  2653.       case GL_PERSPECTIVE_CORRECTION_HINT:
  2654.      *params = (GLint) CC.Hint.PerspectiveCorrection;
  2655.      break;
  2656.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  2657.      *params = CC.Pixel.MapAtoAsize;
  2658.      break;
  2659.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  2660.      *params = CC.Pixel.MapBtoBsize;
  2661.      break;
  2662.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  2663.      *params = CC.Pixel.MapGtoGsize;
  2664.      break;
  2665.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  2666.      *params = CC.Pixel.MapItoAsize;
  2667.      break;
  2668.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  2669.      *params = CC.Pixel.MapItoBsize;
  2670.      break;
  2671.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  2672.      *params = CC.Pixel.MapItoGsize;
  2673.      break;
  2674.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  2675.      *params = CC.Pixel.MapItoIsize;
  2676.      break;
  2677.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  2678.      *params = CC.Pixel.MapItoRsize;
  2679.      break;
  2680.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  2681.      *params = CC.Pixel.MapRtoRsize;
  2682.      break;
  2683.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  2684.      *params = CC.Pixel.MapStoSsize;
  2685.      break;
  2686.       case GL_POINT_SIZE:
  2687.          *params = (GLint) CC.Point.Size;
  2688.          break;
  2689.       case GL_POINT_SIZE_GRANULARITY:
  2690.      *params = (GLint) POINT_SIZE_GRANULARITY;
  2691.      break;
  2692.       case GL_POINT_SIZE_RANGE:
  2693.      params[0] = (GLint) MIN_POINT_SIZE;
  2694.      params[1] = (GLint) MAX_POINT_SIZE;
  2695.      break;
  2696.       case GL_POINT_SMOOTH:
  2697.      *params = (GLint) CC.Point.SmoothFlag;
  2698.      break;
  2699.       case GL_POINT_SMOOTH_HINT:
  2700.      *params = (GLint) CC.Hint.PointSmooth;
  2701.      break;
  2702.       case GL_POLYGON_MODE:
  2703.      params[0] = (GLint) CC.Polygon.FrontMode;
  2704.      params[1] = (GLint) CC.Polygon.BackMode;
  2705.      break;
  2706.       case GL_POLYGON_OFFSET_BIAS_EXT:
  2707.          *params = (GLint) CC.Polygon.OffsetBias;
  2708.          break;
  2709.       case GL_POLYGON_OFFSET_FACTOR_EXT:
  2710.          *params = (GLint) CC.Polygon.OffsetFactor;
  2711.          break;
  2712.       case GL_POLYGON_SMOOTH:
  2713.      *params = (GLint) CC.Polygon.SmoothFlag;
  2714.      break;
  2715.       case GL_POLYGON_SMOOTH_HINT:
  2716.      *params = (GLint) CC.Hint.PolygonSmooth;
  2717.      break;
  2718.       case GL_POLYGON_STIPPLE:
  2719.      for (i=0;i<32;i++) {        /* RIGHT? */
  2720.         params[i] = (GLint) CC.PolygonStipple[i];
  2721.      }
  2722.      break;
  2723.       case GL_PROJECTION_MATRIX:
  2724.      for (i=0;i<16;i++) {
  2725.         params[i] = (GLint) CC.ProjectionMatrix[i];
  2726.      }
  2727.      break;
  2728.       case GL_PROJECTION_STACK_DEPTH:
  2729.      *params = (GLint) CC.ProjectionStackDepth;
  2730.      break;
  2731.       case GL_READ_BUFFER:
  2732.      *params = (GLint) CC.Pixel.ReadBuffer;
  2733.      break;
  2734.       case GL_RED_BIAS:
  2735.          *params = (GLint) CC.Pixel.RedBias;
  2736.          break;
  2737.       case GL_RED_BITS:
  2738.          *params = (GLint) bits( CC.RedScale );
  2739.          break;
  2740.       case GL_RED_SCALE:
  2741.          *params = (GLint) CC.Pixel.RedScale;
  2742.          break;
  2743.       case GL_RENDER_MODE:
  2744.      *params = (GLint) CC.RenderMode;
  2745.      break;
  2746.       case GL_RGBA_MODE:
  2747.      *params = (GLint) CC.RGBAflag;
  2748.      break;
  2749.       case GL_SCISSOR_BOX:
  2750.      params[0] = (GLint) CC.Scissor.X;
  2751.      params[1] = (GLint) CC.Scissor.Y;
  2752.      params[2] = (GLint) CC.Scissor.Width;
  2753.      params[3] = (GLint) CC.Scissor.Height;
  2754.      break;
  2755.       case GL_SCISSOR_TEST:
  2756.      *params = (GLint) CC.Scissor.Enabled;
  2757.      break;
  2758.       case GL_SHADE_MODEL:
  2759.      *params = (GLint) CC.Light.ShadeModel;
  2760.      break;
  2761.       case GL_STENCIL_BITS:
  2762.          *params = (GLint) STENCIL_BITS;
  2763.          break;
  2764.       case GL_STENCIL_CLEAR_VALUE:
  2765.      *params = (GLint) CC.Stencil.Clear;
  2766.      break;
  2767.       case GL_STENCIL_FAIL:
  2768.      *params = (GLint) CC.Stencil.FailFunc;
  2769.      break;
  2770.       case GL_STENCIL_FUNC:
  2771.      *params = (GLint) CC.Stencil.Function;
  2772.      break;
  2773.       case GL_STENCIL_PASS_DEPTH_FAIL:
  2774.      *params = (GLint) CC.Stencil.ZFailFunc;
  2775.      break;
  2776.       case GL_STENCIL_PASS_DEPTH_PASS:
  2777.      *params = (GLint) CC.Stencil.ZPassFunc;
  2778.      break;
  2779.       case GL_STENCIL_REF:
  2780.      *params = (GLint) CC.Stencil.Ref;
  2781.      break;
  2782.       case GL_STENCIL_TEST:
  2783.      *params = (GLint) CC.Stencil.Enabled;
  2784.      break;
  2785.       case GL_STENCIL_VALUE_MASK:
  2786.      *params = (GLint) CC.Stencil.ValueMask;
  2787.      break;
  2788.       case GL_STENCIL_WRITEMASK:
  2789.      *params = (GLint) CC.Stencil.WriteMask;
  2790.      break;
  2791.       case GL_STEREO:
  2792.      *params = 0;  /* TODO */
  2793.      break;
  2794.       case GL_SUBPIXEL_BITS:
  2795.      *params = 0;  /* TODO */
  2796.      break;
  2797.       case GL_TEXTURE_1D:
  2798.      *params = (CC.Texture.Enabled & 1) ? 1.0 : 0.0;
  2799.      break;
  2800.       case GL_TEXTURE_2D:
  2801.      *params = (CC.Texture.Enabled & 2) ? 1.0 : 0.0;
  2802.      break;
  2803.       case GL_TEXTURE_ENV_COLOR:
  2804.      params[0] = FLOAT_TO_INT( CC.Texture.EnvColor[0] );
  2805.      params[1] = FLOAT_TO_INT( CC.Texture.EnvColor[1] );
  2806.      params[2] = FLOAT_TO_INT( CC.Texture.EnvColor[2] );
  2807.      params[3] = FLOAT_TO_INT( CC.Texture.EnvColor[3] );
  2808.      break;
  2809.       case GL_TEXTURE_ENV_MODE:
  2810.      *params = (GLint) CC.Texture.EnvMode;
  2811.      break;
  2812.       case GL_TEXTURE_GEN_S:
  2813.      *params = (CC.Texture.TexGenEnabled & S_BIT) ? 1 : 0;
  2814.      break;
  2815.       case GL_TEXTURE_GEN_T:
  2816.      *params = (CC.Texture.TexGenEnabled & T_BIT) ? 1 : 0;
  2817.      break;
  2818.       case GL_TEXTURE_GEN_R:
  2819.      *params = (CC.Texture.TexGenEnabled & R_BIT) ? 1 : 0;
  2820.      break;
  2821.       case GL_TEXTURE_GEN_Q:
  2822.      *params = (CC.Texture.TexGenEnabled & Q_BIT) ? 1 : 0;
  2823.      break;
  2824.       case GL_TEXTURE_MATRIX:
  2825.          for (i=0;i<16;i++) {
  2826.         params[i] = (GLint) CC.TextureMatrix[i];
  2827.      }
  2828.      break;
  2829.       case GL_TEXTURE_STACK_DEPTH:
  2830.      *params = (GLint) CC.TextureStackDepth;
  2831.      break;
  2832.       case GL_UNPACK_ALIGNMENT:
  2833.      *params = CC.UnpackAlignment;
  2834.      break;
  2835.       case GL_UNPACK_LSB_FIRST:
  2836.      *params = (GLint) CC.UnpackLSBFirst;
  2837.      break;
  2838.       case GL_UNPACK_ROW_LENGTH:
  2839.      *params = CC.UnpackRowLength;
  2840.      break;
  2841.       case GL_UNPACK_SKIP_PIXELS:
  2842.      *params = CC.UnpackSkipPixels;
  2843.      break;
  2844.       case GL_UNPACK_SKIP_ROWS:
  2845.      *params = CC.UnpackSkipRows;
  2846.      break;
  2847.       case GL_UNPACK_SWAP_BYTES:
  2848.      *params = (GLint) CC.UnpackSwapBytes;
  2849.      break;
  2850.       case GL_VIEWPORT:
  2851.          params[0] = (GLint) CC.Viewport.X;
  2852.          params[1] = (GLint) CC.Viewport.Y;
  2853.          params[2] = (GLint) CC.Viewport.Width;
  2854.          params[3] = (GLint) CC.Viewport.Height;
  2855.          break;
  2856.       case GL_ZOOM_X:
  2857.      *params = (GLint) CC.Pixel.ZoomX;
  2858.      break;
  2859.       case GL_ZOOM_Y:
  2860.      *params = (GLint) CC.Pixel.ZoomY;
  2861.      break;
  2862.       default:
  2863.          gl_error( GL_INVALID_ENUM, "glGetIntegerv" );
  2864.    }
  2865. }
  2866.  
  2867.